sinclair 1.11.0 → 1.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c6050b1049de69dd4ba37327f3b0d8e92e1a570ec5f6372ff91b1732bbc3be7
-  data.tar.gz: 68c4c64e8d414bb81d250f180c5f3a6a7f3c180751247a3360b497e53693cf78
+  metadata.gz: b14d0d24d28075129d870b9f2b93c306e894407a70878d7950e0c73e7f747dbb
+  data.tar.gz: 5a3d836d3b8eb5dc299dd17836e50f387fe3273820e91ef95581aac25348407d
 SHA512:
-  metadata.gz: 11a89d1a3b77320298c2027ac33a2a12d7ff57ddda3792753b5e9d0495bb50b3d83904e12ee06b79b84aa615b8796b34c5d087c905aee6a6f77e7d68bed39308
-  data.tar.gz: '04833c0736f37c690b554c007f60a0226255e3730a30c57b5f3a26cb486571c50b0b9f4970e27f581b6829a264321e8277f8eed22592904b1e6af3616ca62328'
+  metadata.gz: c6bbf090685049aaa1936e632ed420060ccead6071bb9864de3b5e26f16ad68431b6d01de24442f4ac4ce87792158a5def414680fe9d6b941d4031b766bd386e
+  data.tar.gz: ef28a8f5b9f5b9e9e12cd36c558fe2bb14fededbea91df46cda1b2d8570d0fec22809dc3e36f4af61844da370ea659463df03562232883121d0ebc7f40a63e81

data/README.md

@@ -13,13 +13,13 @@ This gem helps the creation of complex gems/concerns
 that enables creation of methods on the fly through class
 methods
 
-Current Release: [1.11.0](https://github.com/darthjee/sinclair/tree/1.11.0)
+Current Release: [1.12.1](https://github.com/darthjee/sinclair/tree/1.12.1)
 
-[Next release](https://github.com/darthjee/sinclair/compare/1.11.0...master)
+[Next release](https://github.com/darthjee/sinclair/compare/1.12.1...master)
 
 Yard Documentation
 -------------------
-[https://www.rubydoc.info/gems/sinclair/1.11.0](https://www.rubydoc.info/gems/sinclair/1.11.0)
+[https://www.rubydoc.info/gems/sinclair/1.12.1](https://www.rubydoc.info/gems/sinclair/1.12.1)
 
 Installation
 ---------------
@@ -270,10 +270,14 @@ invalid_object.valid? # returns false
 </details>
 
 #### Different ways of adding the methods
-There are different ways to add a method
+There are different ways to add a method, each accepting different options
+
 <details>
 <summary>Define method using block</summary>
 
+Block methods accepts, as option
+  -  [cache](#caching-the-result): defining the cashing of results
+
 ```ruby
 klass = Class.new
 instance = klass.new
@@ -289,31 +293,57 @@ instance.random_number # returns a number between 10 and 20
 <details>
 <summary>Define method using string</summary>
 
+String methods accepts, as option
+  -  [cache](#caching-the-result): defining the cashing of results
+  -  parameters: defining accepted parameters
+  -  named_parameters: defining accepted named parameters
+
 ```ruby
-klass = Class.new
-instance = klass.new
+# Example without parameters
 
-builder = Sinclair.new(klass)
+class MyClass
+end
+instance = MyClass.new
+
+builder = Sinclair.new(MyClass)
 builder.add_method(:random_number, "Random.rand(10..20)")
 builder.build
 
 instance.random_number # returns a number between 10 and 20
 ```
+
+```ruby
+# Example with parameters
+
+class MyClass
+end
+
+builder = described_class.new(MyClass)
+builder.add_class_method(
+  :function, 'a ** b + c', parameters: [:a], named_parameters: [:b, { c: 15 }]
+)
+builder.build
+
+MyClass.function(10, b: 2) # returns 115
+```
 </details>
 
 <details>
 <summary>Define method using a call to the class</summary>
 
+Call method definitions right now have no options available
+
 ```ruby
-klass = Class.new
+class MyClass
+end
 
-builder = Sinclair.new(klass)
+builder = Sinclair.new(MyClass)
 builder.add_class_method(:attr_accessor, :number, type: :call)
 builder.build
 
-klass.number # returns nil
-klass.number = 10
-klass.number # returns 10
+MyClass.number # returns nil
+MyClass.number = 10
+MyClass.number # returns 10
 ```
 </details>
 

data/config/check_specs.yml

@@ -1,9 +1,9 @@
 ignore:
   - lib/sinclair/comparable/class_methods.rb
   - lib/sinclair/exception.rb
-  - lib/sinclair/matchers/add_method_to.rb
   - lib/sinclair/matchers/add_method.rb
+  - lib/sinclair/matchers/add_method_to.rb
   - lib/sinclair/matchers/base.rb
-  - lib/sinclair/matchers/method_to.rb
   - lib/sinclair/matchers/change_method_on.rb
+  - lib/sinclair/matchers/method_to.rb
   - lib/sinclair/version.rb

data/config/yardstick.yml

@@ -60,6 +60,8 @@ rules:
       - Sinclair::MethodDefinition#initialize
       - Sinclair::MethodDefinition::CallDefinition#initialize
       - Sinclair::MethodDefinition::BlockDefinition#initialize
+      - Sinclair::MethodDefinition::ParameterBuilder#initialize
+      - Sinclair::MethodDefinition::ParameterHelper#initialize
       - Sinclair::MethodDefinition::StringDefinition#initialize
       - Sinclair::Options#initialize
       - Sinclair::Options::Builder#initialize

data/lib/sinclair/method_builder/base.rb

@@ -77,6 +77,21 @@ class Sinclair
       def instance?
         type == INSTANCE_METHOD
       end
+
+      # Returns the klass where the proc block will be evaluated
+      #
+      # For instance type, the class itself is returned
+      #
+      # For adding class methods, the superclass is returned
+      #
+      # @return [Class]
+      def evaluating_class
+        return klass if instance?
+
+        class << klass
+          return self
+        end
+      end
     end
   end
 end

data/lib/sinclair/method_builder/block_method_builder.rb

@@ -14,21 +14,10 @@ class Sinclair
       #
       # @return (see Base#build)
       def build
-        klass.send(method_definition, name, method_block)
+        evaluating_class.define_method(name, method_block)
       end
 
-      private
-
       delegate :name, :method_block, to: :definition
-
-      # @private
-      #
-      # name of the method used to define a new method on class
-      #
-      # @return [Symbol]
-      def method_definition
-        instance? ? :define_method : :define_singleton_method
-      end
     end
   end
 end

data/lib/sinclair/method_builder/call_method_builder.rb

@@ -19,8 +19,6 @@ class Sinclair
         evaluating_class.module_eval(&code_block)
       end
 
-      private
-
       delegate :code_block, to: :definition
       # @method code_block
       # @api private
@@ -29,21 +27,6 @@ class Sinclair
       # Code block to be evaluated by the class
       #
       # @return [Proc]
-
-      # Returns the klass where the proc block will be evaluated
-      #
-      # For instance type, the class itself is returned
-      #
-      # For adding class methods, the superclass is returned
-      #
-      # @return [Class]
-      def evaluating_class
-        return klass if instance?
-
-        class << klass
-          return self
-        end
-      end
     end
   end
 end

data/lib/sinclair/method_builder/string_method_builder.rb

@@ -14,37 +14,10 @@ class Sinclair
       #
       # @return (see Base#build)
       def build
-        klass.module_eval(code_definition, __FILE__, __LINE__ + 1)
+        evaluating_class.module_eval(code_definition, __FILE__, __LINE__ + 1)
       end
 
-      private
-
-      # @private
-      #
-      # string used for method name definition
-      #
-      # the string changes depending if it is
-      # a class or instance method
-      #
-      # @return [String]
-      def definition_name
-        instance? ? name : "self.#{name}"
-      end
-
-      # @private
-      #
-      # string with the code to be defined
-      #
-      # @return [String]
-      def code_definition
-        <<-CODE
-          def #{definition_name}
-            #{code_line}
-          end
-        CODE
-      end
-
-      delegate :code_line, :name, to: :definition
+      delegate :code_definition, to: :definition
     end
   end
 end

data/lib/sinclair/method_builder.rb

@@ -7,10 +7,9 @@ class Sinclair
   # Class responsible for building methods
   class MethodBuilder
     autoload :Base,                'sinclair/method_builder/base'
-    autoload :StringMethodBuilder, 'sinclair/method_builder/string_method_builder'
     autoload :BlockMethodBuilder,  'sinclair/method_builder/block_method_builder'
-
-    autoload :CallMethodBuilder, 'sinclair/method_builder/call_method_builder'
+    autoload :CallMethodBuilder,   'sinclair/method_builder/call_method_builder'
+    autoload :StringMethodBuilder, 'sinclair/method_builder/string_method_builder'
 
     CLASS_METHOD = :class
     INSTANCE_METHOD = :instance

data/lib/sinclair/method_definition/parameter_builder.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+class Sinclair
+  class MethodDefinition
+    # @api private
+    # @author darthjee
+    #
+    # Builder a string of parameters
+    #
+    # This is used when creating the string for a method defined
+    # using a string definition
+    #
+    # @see StringDefinition
+    class ParameterBuilder
+      # Builds a string representing method parameters
+      #
+      # @overload from(parameters, named_parameters)
+      #   @param parameters [Array<Object>] List of parameters.
+      #   @param named_parameters [Array<Object>] List of named parameters
+      #
+      #   The list of +parameters+/+named_parameters+ is formed by an
+      #   array of +Symbol+ representing required parameters
+      #   and +Hash+ representing parameters with default values
+      #
+      # @return [String]
+      def self.from(*args)
+        new(*args).to_s
+      end
+
+      private_class_method :new
+
+      # @param parameters [Array<Object>] List of parameters.
+      # @param named_parameters [Array<Object>] List of named parameters
+      def initialize(parameters, named_parameters)
+        @parameters       = parameters
+        @named_parameters = named_parameters
+      end
+
+      # Returns the parameters string
+      #
+      # @return [String]
+      def to_s
+        return '' if empty_parameters?
+
+        "(#{parameters_string})"
+      end
+
+      private
+
+      attr_reader :parameters, :named_parameters
+
+      # @!method parameters
+      # @api private
+      # @private
+      #
+      # List of parameters
+      #
+      # @return [Array<Object>]
+
+      # @!method named_parameters
+      # @api private
+      # @private
+      #
+      # List of named parameters
+      #
+      # @return [Array<Object>]
+
+      # @private
+      # Flag if any kind of parameters have not been provided
+      #
+      # @return [TrueClass,FalseClass]
+      def empty_parameters?
+        !parameters.present? && !named_parameters.present?
+      end
+
+      # String of parameters witout ()
+      #
+      # This will join all individual parameters strings by +,+
+      #
+      # @return [String]
+      def parameters_string
+        (
+          ParameterHelper.parameters_from(parameters) +
+          ParameterHelper.parameters_from(named_parameters, named: true)
+        ).join(', ')
+      end
+    end
+  end
+end

data/lib/sinclair/method_definition/parameter_helper.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+class Sinclair
+  class MethodDefinition
+    # @api private
+    # @author darthjee
+    #
+    # Helper containing helepr methods for remapping parameters
+    #
+    # @see ParameterBuilder
+    class ParameterHelper
+      # Returns a list of strings of parameters
+      #
+      # @overload parameters_from(parameters_list, named: false)
+      #   @param parameters_list [Array<Object>] list of parameters and defaults
+      #   @param named [TrueClass,FalseClass] Flag informing if the parameters are
+      #     named parameters
+      #
+      # @return [String]
+      def self.parameters_from(*args, **opts)
+        new(*args, **opts).strings
+      end
+
+      private_class_method :new
+
+      # @param parameters_list [Array<Object>] list of parameters and defaults
+      # @param named [TrueClass,FalseClass] Flag informing if the parameters are
+      #   named parameters
+      def initialize(parameters_list, named: false)
+        @parameters_list = parameters_list
+        @named           = named
+      end
+
+      # All parameters converted into strings
+      #
+      # The strings are ready to be pushed into a method definition
+      # and joined by +,+
+      #
+      # @return [Array<String>]
+      def strings
+        return [] unless parameters_list
+
+        parameters_strings + defaults_strings
+      end
+
+      private
+
+      attr_reader :parameters_list, :named
+      alias named? named
+
+      # @!method parameters_list
+      # @api private
+      # @private
+      #
+      # List of parameters and parameters with defaults
+      #
+      # @return [Array<Object>]
+
+      # @!method named
+      # @api private
+      # @private
+      #
+      # Flag informing if the parameters are named parameters
+      #
+      # @return [TrueClass,FalseClass]
+
+      # @!method named?
+      # @api private
+      # @private
+      #
+      # Flag informing if the parameters are named parameters
+      #
+      # @return [TrueClass,FalseClass]
+
+      # Parameters without defaults
+      #
+      # These are filtered out from {#parameters_list} where they are not
+      # of type +Hash+
+      #
+      # @return [Array<Symbol>]
+      def parameters
+        parameters_list.reject do |param|
+          param.is_a?(Hash)
+        end
+      end
+
+      # Hash representing all parameters with default values
+      #
+      # These are filtered out from {#parameters_list} where they are
+      # of type +Hash+ and merged into a single hash
+      #
+      # @return [Hash]
+      def defaults
+        parameters_list.select do |param|
+          param.is_a?(Hash)
+        end.reduce(&:merge) || {}
+      end
+
+      # Parameters without default converted to final string
+      #
+      # {#extra} is added so that for normal parameters the parameter is returned
+      # and for named parameter +:+ is added
+      #
+      # @return [Array<String>]
+      def parameters_strings
+        return parameters.map(&:to_s) unless named?
+
+        parameters.map do |param|
+          "#{param}:"
+        end
+      end
+
+      # Strings representing all parameters with default value
+      #
+      # @return [Array<String>]
+      def defaults_strings
+        joinner = named? ? ': ' : ' = '
+        defaults.map do |key, value|
+          "#{key}#{joinner}#{value.to_json}"
+        end
+      end
+    end
+  end
+end

data/lib/sinclair/method_definition/string_definition.rb

@@ -22,6 +22,30 @@ class Sinclair
       default_value :block?, false
       default_value :string?, true
 
+      # string with the code to be defined
+      #
+      # @return [String]
+      def code_definition
+        <<-CODE
+          def #{name}#{parameters_string}
+            #{code_line}
+          end
+        CODE
+      end
+
+      private
+
+      # @private
+      # String for parameters
+      #
+      # @return [String]
+      def parameters_string
+        ParameterBuilder.from(
+          options_object.parameters, options_object.named_parameters
+        )
+      end
+
+      # @private
       # codeline to be run inside the code
       #
       # @return [String]
@@ -29,8 +53,6 @@ class Sinclair
         cached? ? code_with_cache : code
       end
 
-      private
-
       # @method code
       # @private
       #

data/lib/sinclair/method_definition.rb

@@ -10,9 +10,10 @@ class Sinclair
 
     autoload :BlockHelper,      'sinclair/method_definition/block_helper'
     autoload :BlockDefinition,  'sinclair/method_definition/block_definition'
+    autoload :CallDefinition,   'sinclair/method_definition/call_definition'
     autoload :StringDefinition, 'sinclair/method_definition/string_definition'
-
-    autoload :CallDefinition, 'sinclair/method_definition/call_definition'
+    autoload :ParameterBuilder, 'sinclair/method_definition/parameter_builder'
+    autoload :ParameterHelper,  'sinclair/method_definition/parameter_helper'
 
     # @method name
     #

data/lib/sinclair/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Sinclair
-  VERSION = '1.11.0'
+  VERSION = '1.12.1'
 end

data/spec/integration/readme/sinclair/types_of_definition_spec.rb

@@ -30,6 +30,20 @@ describe Sinclair do
       end
     end
 
+    describe 'Define method using string with parameters' do
+      it 'adds the method' do
+        klass = Class.new
+
+        builder = described_class.new(klass)
+        builder.add_class_method(
+          :function, 'a ** b + c', parameters: [:a], named_parameters: [:b, { c: 15 }]
+        )
+        builder.build
+
+        expect(klass.function(10, b: 2)).to eq(115)
+      end
+    end
+
     describe 'Define method using call to the class' do
       it 'performs the call to the class' do
         klass = Class.new

data/spec/lib/sinclair/method_builder/string_method_builder_spec.rb

@@ -12,9 +12,11 @@ describe Sinclair::MethodBuilder::StringMethodBuilder do
     let(:instance)    { klass.new }
     let(:value)       { Random.rand }
     let(:method_name) { :the_method }
+    let(:code)        { value.to_s }
+    let(:options)     { {} }
 
     let(:definition) do
-      Sinclair::MethodDefinition.from(method_name, value.to_s)
+      Sinclair::MethodDefinition.from(method_name, code, **options)
     end
 
     context 'when type is instance' do
@@ -31,6 +33,27 @@ describe Sinclair::MethodBuilder::StringMethodBuilder do
         it 'returns the result of the code when called' do
           expect(instance.the_method).to eq(value)
         end
+
+        it 'creates a method with no parameters' do
+          expect(instance.method(method_name).parameters)
+            .to be_empty
+        end
+      end
+
+      context 'when the method is built with parameters' do
+        let(:code)    { 'a + b' }
+        let(:options) { { parameters: %i[a b] } }
+
+        before { builder.build }
+
+        it 'returns the result of the code when called' do
+          expect(instance.the_method(12, 23)).to eq(35)
+        end
+
+        it 'creates a method with no parameters' do
+          expect(instance.method(method_name).parameters)
+            .to eq([%i[req a], %i[req b]])
+        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/parameter_helper_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::MethodDefinition::ParameterHelper do
+  describe '.parameters_from' do
+    context 'when parameters are not named' do
+      context 'when there are no defaults' do
+        it 'returns a list of parameters' do
+          expect(described_class.parameters_from(%i[a b]))
+            .to eq(%w[a b])
+        end
+      end
+
+      context 'when there are defaults' do
+        let(:parameters) do
+          [{ a: 10, b: 'word', c: true, d: false }]
+        end
+
+        it 'returns a list of parameters' do
+          expect(described_class.parameters_from(parameters))
+            .to eq(['a = 10', 'b = "word"', 'c = true', 'd = false'])
+        end
+      end
+    end
+
+    context 'when parameters are named' do
+      context 'when there are no defaults' do
+        it 'returns a list of parameters' do
+          expect(described_class.parameters_from(%i[a b], named: true))
+            .to eq(%w[a: b:])
+        end
+      end
+
+      context 'when there are defaults' do
+        let(:parameters) do
+          [{ a: 10, b: 'word', c: true, d: false }]
+        end
+
+        it 'returns a list of parameters' do
+          expect(described_class.parameters_from(parameters, named: true))
+            .to eq(['a: 10', 'b: "word"', 'c: true', 'd: false'])
+        end
+      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

@@ -25,8 +25,18 @@ describe Sinclair::MethodDefinition do
     context 'when the builder has been defined' do
       let(:definition_class) do
         Class.new(described_class) do
-          def code_line
-            '10'
+          attr_reader :name
+
+          def initialize(name)
+            @name = name
+          end
+
+          def code_definition
+            <<-CODE
+            def #{name}
+              10
+            end
+            CODE
           end
         end
       end

data/spec/support/models/dummy_builder.rb

@@ -5,6 +5,7 @@ class Sinclair
     def init
       add_method(:blocked) { 1 }
       add_method(:defined, "@value = value + #{options_object&.increment || 1}")
+      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)

data/spec/support/models/dummy_class_builder.rb

@@ -5,6 +5,7 @@ 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)

data/spec/support/shared_examples/sinclair.rb

@@ -26,6 +26,12 @@ RSpec.shared_examples 'A sinclair builder' do |type|
         expect(object.defined).to eq(1)
         expect(object.defined).to eq(2)
       end
+
+      context 'when the method has custom parameters' do
+        it 'creates a method using the string definition' do
+          expect(object.sum(10, 23)).to eq(33)
+        end
+      end
     end
 
     context 'when describing a method using a block specific type' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinclair
 version: !ruby/object:Gem::Version
-  version: 1.11.0
+  version: 1.12.1
 platform: ruby
 authors:
 - DarthJee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-10 00:00:00.000000000 Z
+date: 2023-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -308,6 +308,8 @@ files:
 - lib/sinclair/method_definition/block_definition.rb
 - lib/sinclair/method_definition/block_helper.rb
 - lib/sinclair/method_definition/call_definition.rb
+- lib/sinclair/method_definition/parameter_builder.rb
+- lib/sinclair/method_definition/parameter_helper.rb
 - lib/sinclair/method_definition/string_definition.rb
 - lib/sinclair/method_definitions.rb
 - lib/sinclair/options.rb
@@ -377,6 +379,8 @@ files:
 - spec/lib/sinclair/method_definition/block_definition_spec.rb
 - spec/lib/sinclair/method_definition/block_helper_spec.rb
 - spec/lib/sinclair/method_definition/call_definition_spec.rb
+- spec/lib/sinclair/method_definition/parameter_builder_spec.rb
+- spec/lib/sinclair/method_definition/parameter_helper_spec.rb
 - spec/lib/sinclair/method_definition/string_definition_spec.rb
 - spec/lib/sinclair/method_definition_spec.rb
 - spec/lib/sinclair/method_definitions_spec.rb