sinclair 1.10.0 → 1.12.0

data/config/check_specs.yml

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

data/config/yardstick.yml

@@ -16,6 +16,8 @@ rules:
   ExampleTag:
     enabled: true
     exclude:
+      - Sinclair#add_method
+      - Sinclair#add_class_method
       - Sinclair::Configurable#config
       - Sinclair::Configurable#reset_config
       - Sinclair::Configurable#configure
@@ -58,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/matchers/add_class_method.rb

@@ -7,7 +7,6 @@ class Sinclair
     #
     # AddClassMethod is able to build an instance of {Sinclair::Matchers::AddClassMethodTo}
     class AddClassMethod < AddMethod
-      # @method #to(target = nil)
       # @example Checking if a class had a class method added
       #   RSpec.configure do |config|
       #     config.include Sinclair::Matchers

data/lib/sinclair/method_builder/base.rb

@@ -7,6 +7,21 @@ class Sinclair
     #
     # Base class responsible for building methods
     class Base
+      # Instantiate the class and build the method
+      #
+      # @param klass [Class] class to receive the method
+      # @param definition [MethodDefinition] method defined
+      # @param type [Symbol] type of method to be build
+      #   - +:instance+ instance methods
+      #   - +:class+ class methods
+      #
+      # @see #build
+      #
+      # @return [Symbol] name of the method built
+      def self.build(klass, definition, type:)
+        new(klass, definition, type: type).build
+      end
+
       # @param klass [Class] class to receive the method
       # @param definition [MethodDefinition] method defined
       # @param type [Symbol] type of method to be build
@@ -22,9 +37,9 @@ class Sinclair
       #
       # @return [Symbol] name of the method built
       #
-      # @raise NotImplementedYet
+      # @raise NotImplementedError
       def build
-        raise 'Not implemented yet. this should be imlemented in subclasses'
+        raise NotImplementedError, 'Not implemented yet. this should be imlemented in subclasses'
       end
 
       private
@@ -62,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

@@ -9,41 +9,24 @@ class Sinclair
     class CallMethodBuilder < Base
       # Builds the method
       #
+      # The build uses +module_eval+ over a class
+      #
+      # The code is ran either on the class itself or in
+      # a block that allow creation of class methods
+      #
       # @return [NilClass]
       def build
-        klass.module_eval(code_line, __FILE__, __LINE__ + 1)
+        evaluating_class.module_eval(&code_block)
       end
 
-      private
-
+      delegate :code_block, to: :definition
+      # @method code_block
       # @api private
       # @private
       #
-      # String to be evaluated when building the method
-      #
-      # This can be {code_string} or {class_code_string}
-      # @return (see MethodDefinition::CallDefinition#code_string)
-      def code_line
-        instance? ? code_string : class_code_string
-      end
-
-      delegate :code_string, :class_code_string, to: :definition
-
-      # @method code_string
-      # @private
-      # @api private
-      #
-      # Delegated from {MethodDefinition::CallDefinition}
-      #
-      # @see MethodDefinition::CallDefinition#code_string
-      # @return [String]
-
-      # @method class_code_string
-      # @private
-      # @api private
+      # Code block to be evaluated by the class
       #
-      # @see MethodDefinition::CallDefinition#class_code_string
-      # @return [String]
+      # @return [Proc]
     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,9 +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 :StringMethodBuilder, 'sinclair/method_builder/string_method_builder'
 
     CLASS_METHOD = :class
     INSTANCE_METHOD = :instance
@@ -24,11 +24,13 @@ class Sinclair
     # @param definitions [MethodDefinitions] all methods
     #   definitions to be built
     # @param type [Symbol] type of method to be built
+    #   - {CLASS_METHOD} : A class method will be built
+    #   - {INSTANCE_METHOD} : An instance method will be built
     #
     # @return [MethodDefinitions]
     def build_methods(definitions, type)
       definitions.each do |definition|
-        build_from_definition(definition, type)
+        definition.build(klass, type)
       end
     end
 
@@ -42,23 +44,5 @@ class Sinclair
     # class to receive the method
     #
     # @return [Class]
-
-    # @private
-    #
-    # Build one method from definition
-    #
-    # @param definition [MethodDefinition] the method definition
-    # @param type [Symbol] type of method to be built
-    #
-    # @return (see Base#build)
-    def build_from_definition(definition, type)
-      if definition.string?
-        StringMethodBuilder.new(klass, definition, type: type).build
-      elsif definition.block?
-        BlockMethodBuilder.new(klass, definition, type: type).build
-      else
-        CallMethodBuilder.new(klass, definition, type: type).build
-      end
-    end
   end
 end

data/lib/sinclair/method_definition/block_definition.rb

@@ -7,6 +7,8 @@ class Sinclair
     #
     # Define a method from block
     class BlockDefinition < MethodDefinition
+      build_with MethodBuilder::BlockMethodBuilder
+
       # @param name    [String,Symbol] name of the method
       # @param block   [Proc] block with code to be added as method
       # @param options [Hash] Options of construction

data/lib/sinclair/method_definition/call_definition.rb

@@ -7,6 +7,8 @@ class Sinclair
     #
     # Define a call of method to e done within the class
     class CallDefinition < MethodDefinition
+      build_with MethodBuilder::CallMethodBuilder
+
       # @param method_name [Symbol] method to be called
       # @param arguments [Array<Symbol,String>] parameters to be passed as
       #   arguments to the call
@@ -18,35 +20,30 @@ class Sinclair
       default_value :block?, false
       default_value :string?, false
 
-      # String to be executed within the class
-      # @return [String]
-      def code_string
-        "#{name} :#{arguments.join(', :')}"
-      end
-
-      # String to be executed within the class running code to change the class itself
+      # Block to be evaluated by the class when adding methods
       #
-      # @see code_string
-      # @return [String]
-      def class_code_string
-        <<-CODE
-          class << self
-            #{code_string}
-          end
-        CODE
+      # The block will be a call from +method_name+ passing +arguments+
+      #   as arguments
+      # @return [Proc]
+      def code_block
+        method_name = name
+        args = arguments
+
+        proc do
+          send(method_name, *args)
+        end
       end
 
       private
 
       attr_reader :arguments
-
       # @method arguments
       # @api private
       # @private
       #
-      # parameters to be passed as arguments to the call
+      # Arguments to be passed when calling the method inside the block
       #
-      # @return [Array<Symbol,String>]
+      # @return [Array<Object>]
     end
   end
 end

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}"
+        end
+      end
+    end
+  end
+end

data/lib/sinclair/method_definition/string_definition.rb

@@ -7,6 +7,8 @@ class Sinclair
     #
     # Define an instance method from string
     class StringDefinition < MethodDefinition
+      build_with MethodBuilder::StringMethodBuilder
+
       # @param name    [String,Symbol] name of the method
       # @param code    [String] code to be evaluated as method
       # @param options [Hash] Options of construction
@@ -20,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]
@@ -27,8 +53,6 @@ class Sinclair
         cached? ? code_with_cache : code
       end
 
-      private
-
       # @method code
       # @private
       #

data/lib/sinclair/method_definition.rb

@@ -10,8 +10,10 @@ class Sinclair
 
     autoload :BlockHelper,      'sinclair/method_definition/block_helper'
     autoload :BlockDefinition,  'sinclair/method_definition/block_definition'
-    autoload :StringDefinition, 'sinclair/method_definition/string_definition'
     autoload :CallDefinition,   'sinclair/method_definition/call_definition'
+    autoload :StringDefinition, 'sinclair/method_definition/string_definition'
+    autoload :ParameterBuilder, 'sinclair/method_definition/parameter_builder'
+    autoload :ParameterHelper,  'sinclair/method_definition/parameter_helper'
 
     # @method name
     #
@@ -59,13 +61,47 @@ class Sinclair
       # The creation is based on type which will be used to infer
       # which subclass of {Sinclair::MethodDefinition} to be used
       #
+      # If type is +nil+ then call is delegated to {.from} which will infer the type
+      # from the arguments
+      #
       # @param type [Symbol] the method definition type
       #
       # @return [Sinclair::MethodDefinition] an instance of a subclass
       def for(type, *args, **options, &block)
+        return from(*args, **options, &block) unless type
+
         klass = const_get("#{type}_definition".camelize)
         klass.new(*args, **options, &block)
       end
+
+      # Defines builder for a definition class
+      #
+      # @param builder_class [Class<MethodBuilder>]
+      #
+      # @return [Symbol] constant +:build+
+      #
+      # @!macro build_with
+      #   @api private
+      #
+      #   @!method build(klass, type)
+      #
+      #   Builds the method defined
+      #
+      #   The method is built using {$1}
+      #
+      #   @param klass [Class] The class where the method will be built
+      #   @param type [Symbol] type of method to be built
+      #     - {MethodBuilder::CLASS_METHOD} : A class method will be built
+      #     - {MethodBuilder::INSTANCE_METHOD} : An instance method will be built
+      #
+      #   @see $1#build
+      #
+      #   @return [Symbol] the name of the method built
+      def build_with(builder_class)
+        define_method(:build) do |klass, type|
+          builder_class.build(klass, self, type: type)
+        end
+      end
     end
 
     # @param name    [String,Symbol] name of the method
@@ -87,10 +123,13 @@ class Sinclair
     #
     # @example (see MethodDefinition::StringDefinition#build)
     # @example (see MethodDefinition::BlockDefinition#build)
+    # @example (see MethodDefinition::CallDefinition#build)
     #
     # @return [Symbol] name of the created method
-    def build(_klass)
-      raise 'Build is implemented in subclasses. ' \
+    #
+    # @raise NotImplementedError
+    def build(_klass, _type)
+      raise NotImplementedError, 'Build is implemented in subclasses. ' \
         "Use #{self.class}.from to initialize a proper object"
     end