spec/lib/sinclair/method_definitions_spec.rb in sinclair-1.10.0 vs spec/lib/sinclair/method_definitions_spec.rb in sinclair-1.11.0

@@ -4,11 +4,12 @@
 
 describe Sinclair::MethodDefinitions do
   subject(:definitions) { described_class.new }
 
   describe '#add' do
-    let(:name) { :the_method }
+    let(:name)  { :the_method }
+    let(:klass) { Class.new }
 
     context 'when passing block' do
       it 'returns the resulting array' do
         expect(definitions.add(name) { RandomGenerator.rand })
           .to be_a(Array)
@@ -39,85 +40,83 @@
       it 'creates a new StringDefinition' do
         expect(definitions.add(name, 'RandomGenerator.rand').last)
           .to be_a(Sinclair::MethodDefinition::StringDefinition)
       end
     end
-  end
 
-  describe '#add_definition' do
     context 'when there are no options nor block' do
       let(:type)      { :call }
       let(:arguments) { %i[attr_reader some_attribute other_attribute] }
 
       it do
-        expect(definitions.add_definition(type, *arguments))
+        expect(definitions.add(*arguments, type: type))
           .to be_a(Array)
       end
 
       it 'creates a new definition' do
-        expect(definitions.add_definition(type, *arguments).last)
+        expect(definitions.add(*arguments, type: type).last)
           .to be_a(Sinclair::MethodDefinition)
       end
 
       it 'creates a new definition of the chosen type' do
-        expect(definitions.add_definition(type, *arguments).last)
+        expect(definitions.add(*arguments, type: type).last)
           .to be_a(Sinclair::MethodDefinition::CallDefinition)
       end
 
       it 'initializes it correctly' do
-        expect(definitions.add_definition(type, *arguments).last.code_string)
-          .to eq('attr_reader :some_attribute, :other_attribute')
+        expect { klass.module_eval(&definitions.add(*arguments, type: type).last.code_block) }
+          .to add_method(:some_attribute).to(klass)
       end
     end
 
     context 'when a block is given' do
       let(:type)        { :block }
       let(:method_name) { :the_method }
       let(:block)       { proc { 10 } }
 
       it do
-        expect(definitions.add_definition(type, method_name, &block))
+        expect(definitions.add(type, method_name, &block))
           .to be_a(Array)
       end
 
       it 'creates a new definition' do
-        expect(definitions.add_definition(type, method_name, &block).last)
+        expect(definitions.add(type, method_name, &block).last)
           .to be_a(Sinclair::MethodDefinition)
       end
 
       it 'creates a new definition of the chosen type' do
-        expect(definitions.add_definition(type, method_name, &block).last)
+        expect(definitions.add(type, method_name, &block).last)
           .to be_a(Sinclair::MethodDefinition::BlockDefinition)
       end
 
       it 'initializes it correctly' do
-        expect(definitions.add_definition(type, method_name, &block).last.name)
+        expect(definitions.add(method_name, type: type, &block).last.name)
           .to eq(method_name)
       end
     end
 
     context 'when options are given' do
       let(:type)        { :string }
       let(:method_name) { :the_method }
       let(:code)        { '10' }
 
       it do
-        expect(definitions.add_definition(type, method_name, code))
+        expect(definitions.add(method_name, code, type: type))
           .to be_a(Array)
       end
 
       it 'creates a new definition' do
-        expect(definitions.add_definition(type, method_name, code).last)
+        expect(definitions.add(method_name, code, type: type).last)
           .to be_a(Sinclair::MethodDefinition)
       end
 
       it 'creates a new definition of the chosen type' do
-        expect(definitions.add_definition(type, method_name, code).last)
+        expect(definitions.add(method_name, code, type: type).last)
           .to be_a(Sinclair::MethodDefinition::StringDefinition)
       end
 
       it 'initializes it correctly' do
-        expect(definitions.add_definition(type, method_name, code).last.name)
+        expect(definitions.add(method_name, code, type: type).last.name)
           .to eq(method_name)
       end
     end
   end
 end