sinclair 1.10.0 → 1.12.0

data/spec/lib/sinclair/method_definition/call_definition_spec.rb

@@ -10,27 +10,24 @@ describe Sinclair::MethodDefinition::CallDefinition do
   let(:call_name)  { :method_call }
   let(:attributes) { %i[key1 value2] }
 
-  describe '#code_string' do
-    let(:expected) { 'method_call :key1, :value2' }
-
-    it 'returns the code string' do
-      expect(definition.code_string)
-        .to eq(expected)
+  describe '#code_block' do
+    let(:instance) { klass.new }
+    let(:klass) do
+      Class.new do
+        def method_call(*args)
+          args
+        end
+      end
     end
-  end
 
-  describe '#class_code_string' do
-    let(:expected) do
-      <<-RUBY
-      class << self
-        method_call :key1, :value2
-      end
-      RUBY
+    it do
+      expect(definition.code_block)
+        .to be_a(Proc)
     end
 
-    it 'returns the code string' do
-      expect(definition.class_code_string.gsub(/^ */, ''))
-        .to eq(expected.gsub(/^ */, ''))
+    it 'returns a proc with the method call' do
+      expect(instance.instance_eval(&definition.code_block))
+        .to eq(attributes)
     end
   end
 end

data/spec/lib/sinclair/method_definition/parameter_builder_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::MethodDefinition::ParameterBuilder do
+  describe '.from' do
+    let(:parameters)       { nil }
+    let(:named_parameters) { nil }
+
+    context 'when parameters and named_parameters are nil' do
+      it do
+        expect(described_class.from(parameters, named_parameters))
+          .to eq('')
+      end
+    end
+
+    context 'when parameters is empty' do
+      let(:parameters) { [] }
+
+      it do
+        expect(described_class.from(parameters, named_parameters))
+          .to eq('')
+      end
+    end
+
+    context 'when named_parameters is empty' do
+      let(:named_parameters) { [] }
+
+      it do
+        expect(described_class.from(parameters, named_parameters))
+          .to eq('')
+      end
+    end
+
+    context 'when parameters has no default values' do
+      let(:parameters) { %i[x y] }
+
+      it do
+        expect(described_class.from(parameters, named_parameters))
+          .to eq('(x, y)')
+      end
+    end
+
+    context 'when named_parameters has no default values' do
+      let(:named_parameters) { %i[x y] }
+
+      it do
+        expect(described_class.from(parameters, named_parameters))
+          .to eq('(x:, y:)')
+      end
+    end
+
+    context 'when parameters has only default values' do
+      let(:parameters) { [{ x: 1, y: 3 }] }
+
+      it do
+        expect(described_class.from(parameters, named_parameters))
+          .to eq('(x = 1, y = 3)')
+      end
+    end
+
+    context 'when named parameters has only default values' do
+      let(:named_parameters) { [{ x: 1, y: 3 }] }
+
+      it do
+        expect(described_class.from(parameters, named_parameters))
+          .to eq('(x: 1, y: 3)')
+      end
+    end
+
+    context 'when all options are present' do
+      let(:parameters) { [:x, { y: 2 }] }
+      let(:named_parameters) { [:a, { b: 3 }] }
+
+      it do
+        expect(described_class.from(parameters, named_parameters))
+          .to eq('(x, y = 2, a:, b: 3)')
+      end
+    end
+  end
+end

data/spec/lib/sinclair/method_definition/string_definition_spec.rb

@@ -11,59 +11,90 @@ describe Sinclair::MethodDefinition::StringDefinition do
   let(:code)        { 'Random.rand' }
   let(:options)     { {} }
 
-  describe '#code_line' do
-    let(:klass)     { Class.new }
-    let(:instance)  { klass.new }
-    let(:code_line) { definition.code_line }
-
-    it 'returns the code' do
-      expect(definition.code_line).to eq(code)
+  describe '#code_definition' do
+    let(:klass) { Class.new }
+    let(:instance)        { klass.new }
+    let(:code_definition) { definition.code_definition }
+    let(:expected_code) do
+      <<-CODE
+      def #{method_name}
+        #{code}
+      end
+      CODE
     end
 
     it 'returns a code with no cache' do
-      expect(instance.instance_eval(code_line))
-        .not_to eq(instance.instance_eval(code_line))
+      expect(definition.code_definition.gsub(/^ */, ''))
+        .to eq(expected_code.gsub(/^ */, ''))
     end
 
-    context 'when cache true is given' do
-      let(:options) { { cached: true } }
+    context 'when parameters are given with defaults' do
+      let(:options) { { parameters: [:x, { y: 10 }] } }
+      let(:code)    { 'x + y' }
+      let(:expected_code) do
+        <<-CODE
+        def #{method_name}(x, y = 10)
+          #{code}
+        end
+        CODE
+      end
 
       it 'returns the code with simple cache' do
-        expect(definition.code_line)
-          .to eq("@#{method_name} ||= #{code}")
+        expect(definition.code_definition.gsub(/^ */, ''))
+          .to eq(expected_code.gsub(/^ */, ''))
       end
+    end
 
-      it 'returns a code with cache' do
-        expect(instance.instance_eval(code_line))
-          .to eq(instance.instance_eval(code_line))
+    context 'when parameters are given' do
+      let(:options) { { parameters: %i[x y] } }
+      let(:code)    { 'x + y' }
+      let(:expected_code) do
+        <<-CODE
+        def #{method_name}(x, y)
+          #{code}
+        end
+        CODE
+      end
+
+      it 'returns the code with simple cache' do
+        expect(definition.code_definition.gsub(/^ */, ''))
+          .to eq(expected_code.gsub(/^ */, ''))
       end
+    end
 
-      it 'returns a code that does not cache nil' do
-        instance.instance_variable_set("@#{method_name}", nil)
+    context 'when cache true is given' do
+      let(:options) { { cached: true } }
+      let(:expected_code) do
+        <<-CODE
+        def #{method_name}
+          @#{method_name} ||= #{code}
+        end
+        CODE
+      end
 
-        expect(instance.instance_eval(code_line)).not_to be_nil
+      it 'returns the code with simple cache' do
+        expect(definition.code_definition.gsub(/^ */, ''))
+          .to eq(expected_code.gsub(/^ */, ''))
       end
     end
 
     context 'when cache full is given' do
       let(:options) { { cached: :full } }
       let(:expected) do
-        "defined?(@#{method_name}) ? @#{method_name} : (@#{method_name} = #{code})"
+        <<-CODE
+        def #{method_name}
+          defined?(@#{method_name}) ? @#{method_name} : (@#{method_name} = #{code})
+        end
+        CODE
       end
 
       it 'returns the code with full cache' do
-        expect(definition.code_line).to eq(expected)
+        expect(definition.code_definition.gsub(/^ */, '')).to eq(expected.gsub(/^ */, ''))
       end
 
       it 'returns a code with cache' do
-        expect(instance.instance_eval(code_line))
-          .to eq(instance.instance_eval(code_line))
-      end
-
-      it 'returns a code that caches nil' do
-        instance.instance_variable_set("@#{method_name}", nil)
-
-        expect(instance.instance_eval(code_line)).to be_nil
+        expect(instance.instance_eval(code_definition))
+          .to eq(instance.instance_eval(code_definition))
       end
     end
   end

data/spec/lib/sinclair/method_definition_spec.rb

@@ -5,6 +5,58 @@ require 'spec_helper'
 describe Sinclair::MethodDefinition do
   let(:method_name) { :the_method }
 
+  describe '.build' do
+    subject(:definition) do
+      definition_class.new(method_name, **options)
+    end
+
+    let(:definition_class) { Class.new(described_class) }
+    let(:options)          { {} }
+    let(:klass)            { Class.new }
+    let(:type)             { Sinclair::MethodBuilder::CLASS_METHOD }
+
+    context 'when the builder has not been defined' do
+      it do
+        expect { definition.build(klass, type) }
+          .to raise_error(NotImplementedError)
+      end
+    end
+
+    context 'when the builder has been defined' do
+      let(:definition_class) do
+        Class.new(described_class) do
+          attr_reader :name
+
+          def initialize(name)
+            @name = name
+          end
+
+          def code_definition
+            <<-CODE
+            def #{name}
+              10
+            end
+            CODE
+          end
+        end
+      end
+
+      before do
+        definition_class.build_with(Sinclair::MethodBuilder::StringMethodBuilder)
+      end
+
+      it do
+        expect { definition.build(klass, type) }
+          .not_to raise_error
+      end
+
+      it 'builds the method using the builder' do
+        expect { definition.build(klass, type) }
+          .to add_class_method(method_name).to(klass)
+      end
+    end
+  end
+
   describe '.default_value' do
     subject(:klass) { Class.new(described_class) }
 
@@ -44,6 +96,8 @@ describe Sinclair::MethodDefinition do
   end
 
   describe '.for' do
+    let(:klass) { Class.new }
+
     context 'when there are no options nor block' do
       let(:type)      { :call }
       let(:arguments) { %i[attr_reader some_attribute other_attribute] }
@@ -59,8 +113,29 @@ describe Sinclair::MethodDefinition do
       end
 
       it 'initializes it correctly' do
-        expect(described_class.for(type, *arguments).code_string)
-          .to eq('attr_reader :some_attribute, :other_attribute')
+        expect { klass.module_eval(&described_class.for(type, *arguments).code_block) }
+          .to add_method(:some_attribute).to(klass)
+      end
+    end
+
+    context 'when type is not given' do
+      let(:type)        { nil }
+      let(:method_name) { :the_method }
+      let(:block)       { proc { 10 } }
+
+      it do
+        expect(described_class.for(type, method_name, &block))
+          .to be_a(described_class)
+      end
+
+      it 'infers the definition from arguments' do
+        expect(described_class.for(type, method_name, &block))
+          .to be_a(described_class::BlockDefinition)
+      end
+
+      it 'initializes it correctly' do
+        expect(described_class.for(type, method_name, &block).name)
+          .to eq(method_name)
       end
     end
 

data/spec/lib/sinclair/method_definitions_spec.rb

@@ -6,7 +6,8 @@ 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
@@ -41,31 +42,29 @@ describe Sinclair::MethodDefinitions do
           .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
 
@@ -75,22 +74,22 @@ describe Sinclair::MethodDefinitions do
       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
@@ -101,22 +100,22 @@ describe Sinclair::MethodDefinitions do
       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

data/spec/lib/sinclair_spec.rb

@@ -11,86 +11,15 @@ describe Sinclair do
   let(:builder_class) { described_class }
 
   describe '#add_method' do
-    context 'when extending the class' do
-      let(:builder_class) { described_class::DummyBuilder }
+    let(:object) { instance }
 
-      before do
-        builder.init
-        builder.build
-      end
-
-      context 'when describing a method with block' do
-        it 'creates a method with the block' do
-          expect(instance.blocked).to eq(1)
-        end
-      end
-
-      context 'when describing a method with string' do
-        it 'creates a method using the string definition' do
-          expect(instance.defined).to eq(1)
-          expect(instance.defined).to eq(2)
-        end
-      end
-
-      context 'when passing options' do
-        let(:options) { { increment: 2 } }
-
-        it 'parses the options' do
-          expect(instance.defined).to eq(2)
-          expect(instance.defined).to eq(4)
-        end
-      end
-    end
-
-    context 'when using the builder without extending' do
-      context 'when declaring a method with a block' do
-        before do
-          builder.add_method(:blocked) { 1 }
-          builder.add_method(:blocked) { 2 }
-          builder.build
-        end
-
-        it 'respect the order of method addtion' do
-          expect(instance.blocked).to eq(2)
-        end
-      end
-
-      context 'when declaring a method string' do
-        before do
-          builder.add_method(:string, '1')
-          builder.add_method(:string, '2')
-          builder.build
-        end
-
-        it 'respect the order of method addtion' do
-          expect(instance.string).to eq(2)
-        end
-      end
-
-      context 'when declaring block and string' do
-        before do
-          builder.add_method(:value) { 1 }
-          builder.add_method(:value, '2')
-          builder.build
-        end
-
-        it 'respect the order of method addtion' do
-          expect(instance.value).to eq(2)
-        end
-      end
+    it_behaves_like 'A sinclair builder', :instance
+  end
 
-      context 'when declaring string and block' do
-        before do
-          builder.add_method(:value, '1')
-          builder.add_method(:value) { 2 }
-          builder.build
-        end
+  describe '#add_class_method' do
+    let(:object) { dummy_class }
 
-        it 'respect the order of method addtion' do
-          expect(instance.value).to eq(2)
-        end
-      end
-    end
+    it_behaves_like 'A sinclair builder', :class
   end
 
   describe '#eval_and_add_method' do
@@ -149,87 +78,4 @@ describe Sinclair do
       end
     end
   end
-
-  describe '#add_class_method' do
-    context 'when extending the class' do
-      let(:builder_class) { described_class::DummyClassBuilder }
-
-      before do
-        builder.init
-        builder.build
-      end
-
-      context 'when describing a method with block' do
-        it 'creates a method with the block' do
-          expect(dummy_class.blocked).to eq(1)
-        end
-      end
-
-      context 'when describing a method with string' do
-        it 'creates a method using the string definition' do
-          expect(dummy_class.defined).to eq(1)
-          expect(dummy_class.defined).to eq(2)
-        end
-      end
-
-      context 'when passing options' do
-        let(:options) { { increment: 2 } }
-
-        it 'parses the options' do
-          expect(dummy_class.defined).to eq(2)
-          expect(dummy_class.defined).to eq(4)
-        end
-      end
-    end
-
-    context 'when using the builder without extending' do
-      context 'when declaring a method with a block' do
-        before do
-          builder.add_class_method(:blocked) { 1 }
-          builder.add_class_method(:blocked) { 2 }
-          builder.build
-        end
-
-        it 'respect the order of method addtion' do
-          expect(dummy_class.blocked).to eq(2)
-        end
-      end
-
-      context 'when declaring a method string' do
-        before do
-          builder.add_class_method(:string, '1')
-          builder.add_class_method(:string, '2')
-          builder.build
-        end
-
-        it 'respect the order of method addtion' do
-          expect(dummy_class.string).to eq(2)
-        end
-      end
-
-      context 'when declaring block and string' do
-        before do
-          builder.add_class_method(:value) { 1 }
-          builder.add_class_method(:value, '2')
-          builder.build
-        end
-
-        it 'respect the order of method addtion' do
-          expect(dummy_class.value).to eq(2)
-        end
-      end
-
-      context 'when declaring string and block' do
-        before do
-          builder.add_class_method(:value, '1')
-          builder.add_class_method(:value) { 2 }
-          builder.build
-        end
-
-        it 'respect the order of method addtion' do
-          expect(dummy_class.value).to eq(2)
-        end
-      end
-    end
-  end
 end

data/spec/support/models/dummy_builder.rb

@@ -5,7 +5,11 @@ class Sinclair
     def init
       add_method(:blocked) { 1 }
       add_method(:defined, "@value = value + #{options_object&.increment || 1}")
-      add_method(:value, '@value ||= 0')
+      add_method(:sum, 'x + y', parameters: %i[x y])
+      add_method(:value, cached: true) { 0 }
+      add_method(:type_block, type: :block) { 3 }
+      add_method(:type_string, '10', type: :string)
+      add_method(:attr_accessor, :some_attribute, type: :call)
     end
   end
 end

data/spec/support/models/dummy_class_builder.rb

@@ -5,7 +5,11 @@ class Sinclair
     def init
       add_class_method(:blocked) { 1 }
       add_class_method(:defined, "@value = value + #{options_object&.increment || 1}")
+      add_class_method(:sum, 'x + y', parameters: %i[x y])
       add_class_method(:value, '@value ||= 0')
+      add_class_method(:type_block, type: :block) { 3 }
+      add_class_method(:type_string, '10', type: :string)
+      add_class_method(:attr_accessor, :some_attribute, type: :call)
     end
   end
 end

data/spec/support/models/person.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Person
-  attr_reader :first_name, :last_name
+  attr_accessor :first_name, :last_name
 
   def initialize(first_name, last_name)
     @first_name = first_name