sinclair 1.10.0 → 1.11.0

data/config/check_specs.yml

@@ -1,10 +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/version.rb
-  - lib/sinclair/method_builder/base.rb
-  - lib/sinclair/exception.rb
-  - lib/sinclair/matchers/method_to.rb
   - lib/sinclair/matchers/base.rb
+  - lib/sinclair/matchers/method_to.rb
   - lib/sinclair/matchers/change_method_on.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

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

data/lib/sinclair/method_builder/call_method_builder.rb

@@ -9,41 +9,41 @@ 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
+      # Code block to be evaluated by the class
       #
-      # 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
+      # @return [Proc]
 
-      delegate :code_string, :class_code_string, to: :definition
-
-      # @method code_string
-      # @private
-      # @api private
+      # Returns the klass where the proc block will be evaluated
       #
-      # Delegated from {MethodDefinition::CallDefinition}
+      # For instance type, the class itself is returned
       #
-      # @see MethodDefinition::CallDefinition#code_string
-      # @return [String]
-
-      # @method class_code_string
-      # @private
-      # @api private
+      # For adding class methods, the superclass is returned
       #
-      # @see MethodDefinition::CallDefinition#class_code_string
-      # @return [String]
+      # @return [Class]
+      def evaluating_class
+        return klass if instance?
+
+        class << klass
+          return self
+        end
+      end
     end
   end
 end

data/lib/sinclair/method_builder.rb

@@ -9,7 +9,8 @@ class Sinclair
     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'
 
     CLASS_METHOD = :class
     INSTANCE_METHOD = :instance
@@ -24,11 +25,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 +45,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/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

data/lib/sinclair/method_definition.rb

@@ -11,7 +11,8 @@ 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 :CallDefinition, 'sinclair/method_definition/call_definition'
 
     # @method name
     #
@@ -59,13 +60,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 +122,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
 

data/lib/sinclair/method_definitions.rb

@@ -12,37 +12,35 @@ class Sinclair
     #
     # The type is decided based in the arguments
     #
-    # @param name [String,Symbol] method name
-    # @param options [Hash] Options of construction
-    # @option options cached [Boolean] Flag telling to create
-    #   a method with cache
-    #
     # @overload add(definition_class, name, code = nil, **options)
+    #   @param name [String,Symbol] method name
     #   @param code [String] code to be evaluated when the method is ran
+    #   @param options [Hash] Options of construction
+    #   @option options cached [Boolean] Flag telling to create
+    #     a method with cache
     #
     # @overload add(definition_class, name, **options, &block)
+    #   @param name [String,Symbol] method name
+    #   @param options [Hash] Options of construction
+    #   @option options cached [Boolean] Flag telling to create
+    #     a method with cache
     #   @param block [Proc]  block to be ran as method
     #
-    # @return [Array<MethodDefinition>]
-    def add(name, code = nil, **options, &block)
-      definitions << MethodDefinition.from(name, code, **options, &block)
-    end
-
-    # Builds and adds new definition
-    #
-    # The type is decided based on the argument +type+
+    # @overload add(type, *args, **options, &block)
+    #   @param type [Symbol] type of definition
+    #     - :string -> {MethodDefinition::StringDefinition}
+    #     - :block -> {MethodDefinition::BlockDefinition}
+    #     - :call -> {MethodDefinition::CallDefinition}
+    #   @param options [Hash] Options of construction
+    #   @option options cached [Boolean] Flag telling to create
+    #     a method with cache
+    #   @param block [Proc]  block to be ran as method
     #
-    # @param type [Symbol] type of definition
-    #   - :string -> {MethodDefinition::StringDefinition}
-    #   - :block -> {MethodDefinition::BlockDefinition}
-    #   - :call -> {MethodDefinition::CallDefinition}
-    # @param options [Hash] Options of construction
-    # @option options cached [Boolean] Flag telling to create
-    #   a method with cache
-    # @param block [Proc]  block to be ran as method
+    # @see MethodDefinition.for
+    # @see MethodDefinition.from
     #
     # @return [Array<MethodDefinition>]
-    def add_definition(type, *args, **options, &block)
+    def add(*args, type: nil, **options, &block)
       definitions << MethodDefinition.for(type, *args, **options, &block)
     end
 

data/lib/sinclair/version.rb

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

data/lib/sinclair.rb

@@ -179,107 +179,193 @@ class Sinclair
   end
 
   # Add a method to the method list to be created on klass instances
-  #
-  # @param name [String,Symbol] name of the method to be added
-  # @param options [Hash] Options of construction
-  # @option options cached [Boolean] Flag telling to create
-  #   a method with cache
+  # @see MethodDefinitions#add
   #
   # @overload add_method(name, code, **options)
+  #   @param name [String,Symbol] name of the method to be added
   #   @param code [String] code to be evaluated when the method is ran
+  #   @param options [Hash] Options of construction
+  #   @option options cached [Boolean] Flag telling to create
+  #     a method with cache
+  #   @see MethodDefinition::StringDefinition
+  #
+  #   @example Using string code to add a string defined method
+  #     class Person
+  #       attr_accessor :first_name, :last_name
+  #
+  #       def initialize(first_name, last_name)
+  #         @first_name = first_name
+  #         @last_name = last_name
+  #       end
+  #     end
+  #
+  #     builder = Sinclair.new(Person)
+  #     builder.add_method(:full_name, '[first_name, last_name].join(" ")')
+  #     builder.build
+  #
+  #     Person.new('john', 'wick').full_name # returns 'john wick'
   #
   # @overload add_method(name, **options, &block)
+  #   @param name [String,Symbol] name of the method to be added
   #   @param block [Proc]  block to be ran as method
+  #   @param options [Hash] Options of construction
+  #   @option options cached [Boolean] Flag telling to create
+  #     a method with cache
+  #   @see MethodDefinition::BlockDefinition
+  #
+  #   @example Using block to add a block method
+  #     class Person
+  #       attr_accessor :first_name, :last_name
+  #
+  #       def initialize(first_name, last_name)
+  #         @first_name = first_name
+  #         @last_name = last_name
+  #       end
+  #     end
   #
-  # @example Using string code
-  #   class Person
-  #     attr_reader :first_name, :last_name
-  #
-  #     def initialize(first_name, last_name)
-  #       @first_name = first_name
-  #       @last_name = last_name
+  #     builder = Sinclair.new(Person)
+  #     builder.add_method(:bond_name) { "#{last_name}, #{first_name} #{last_name}" }
+  #     builder.build
+  #
+  #     Person.new('john', 'wick').bond_name # returns 'wick, john wick'
+  #
+  # @overload add_method(*args, type:, **options, &block)
+  #   @param args [Array<Object>] arguments to be passed to the definition
+  #   @param type [Symbol] type of method definition
+  #   @param block [Proc]  block to be ran as method when type is block
+  #   @param options [Hash] Options of construction
+  #   @option options cached [Boolean] Flag telling to create
+  #     a method with cache
+  #   @see MethodDefinition::BlockDefinition
+  #   @see MethodDefinition::StringDefinition
+  #   @see MethodDefinition::CallDefinition
+  #
+  #   @example Passing type block
+  #     class Person
+  #       attr_accessor :first_name, :last_name
+  #
+  #       def initialize(first_name, last_name)
+  #         @first_name = first_name
+  #         @last_name = last_name
+  #       end
   #     end
-  #   end
   #
-  #   builder = Sinclair.new(Person)
-  #   builder.add_method(:full_name, '[first_name, last_name].join(" ")')
-  #   builder.build
+  #     builder = Sinclair.new(Person)
+  #     builder.add_method(:bond_name, type: :block, cached: true) do
+  #       "{last_name}, #{first_name} #{last_name}"
+  #     end
+  #     builder.build
   #
-  #   Person.new('john', 'wick').full_name # returns 'john wick'
+  #     person.Person.new('john', 'wick')
   #
-  # @example Using block
-  #   class Person
-  #     attr_reader :first_name, :last_name
+  #     person.bond_name # returns 'wick, john wick'
+  #     person.first_name = 'Johny'
+  #     person.bond_name # returns 'wick, john wick'
   #
-  #     def initialize(first_name, last_name)
-  #       @first_name = first_name
-  #       @last_name = last_name
+  #   @example Passing type call
+  #     class Person
   #     end
-  #   end
   #
-  #   builder = Sinclair.new(Person)
-  #   builder.add_method(:full_name, '[first_name, last_name].join(" ")')
-  #   builder.add_method(:bond_name) { "#{last_name}, #{full_name}" }
-  #   builder.build
+  #     builder = Sinclair.new(Person)
+  #     builder.add_method(:attr_accessor, :bond_name, type: :call)
+  #     builder.build
   #
-  #   Person.new('john', 'wick').bond_name # returns 'wick, john wick'
-  # @return [Array<MethodDefinition>]
-  def add_method(name, code = nil, **options, &block)
-    definitions.add(
-      name, code, **options, &block
-    )
+  #     person.bond_name = 'Bond, James Bond'
+  #     person.bond_name # returns 'Bond, James Bond'
+  #
+  # @return [Array<MethodDefinition>] the list of all currently defined instance methods
+  def add_method(*args, type: nil, **options, &block)
+    definitions.add(*args, type: type, **options, &block)
   end
 
   # Add a method to the method list to be created on klass
-  #
-  # @param name [String,Symbol] name of the method to be added
-  # @param options [Hash] Options of construction
-  # @option options cached [Boolean] Flag telling to create
-  #   a method with cache
+  # @see MethodDefinitions#add
   #
   # @overload add_class_method(name, code, **options)
+  #   @param name [String,Symbol] name of the method to be added
   #   @param code [String] code to be evaluated when the method is ran
+  #   @param options [Hash] Options of construction
+  #   @option options cached [Boolean] Flag telling to create
+  #     a method with cache
+  #
+  #   @example Adding a method by String
+  #     class EnvFetcher
+  #     end
+  #
+  #     builder = Sinclair.new(EnvFetcher)
+  #
+  #     builder.add_class_method(:hostname, 'ENV["HOSTNAME"]')
+  #     builder.build
+  #
+  #     ENV['HOSTNAME'] = 'myhost'
+  #
+  #     EnvFetcher.hostname # returns 'myhost'
   #
   # @overload add_class_method(name, **options, &block)
+  #   @param name [String,Symbol] name of the method to be added
   #   @param block [Proc]  block to be ran as method
+  #   @param options [Hash] Options of construction
+  #   @option options cached [Boolean] Flag telling to create
+  #     a method with cache
   #
-  # @example
-  #   class EnvFetcher
-  #   end
+  #   @example Adding a method by Block
+  #     class EnvFetcher
+  #     end
   #
-  #   builder = Sinclair.new(EnvFetcher)
+  #     builder = Sinclair.new(EnvFetcher)
   #
-  #   builder.add_class_method(:hostname, 'ENV["HOSTNAME"]')
-  #   builder.build
+  #     builder.add_class_method(:timeout) { ENV['TIMEOUT'] }
+  #     builder.build
   #
-  #   ENV['HOSTNAME'] = 'myhost'
+  #     ENV['TIMEOUT'] = '300'
   #
-  #   env_fetcher.hostname # returns 'myhost'
+  #     EnvFetcher.timeout # returns '300'
   #
-  # @example
-  #   class EnvFetcher
-  #   end
+  # @overload add_class_method(*args, type: **options, &block)
+  #   @param args [Array<Object>] arguments to be passed to the definition
+  #   @param type [Symbol] type of method definition
+  #   @param block [Proc]  block to be ran as method when type is block
+  #   @param options [Hash] Options of construction
+  #   @option options cached [Boolean] Flag telling to create
+  #     a method with cache
+  #   @see MethodDefinition::BlockDefinition
+  #   @see MethodDefinition::StringDefinition
+  #   @see MethodDefinition::CallDefinition
   #
-  #   builder = Sinclair.new(EnvFetcher)
+  #   @example Passing type block
+  #     class EnvFetcher
+  #     end
   #
-  #   builder.add_class_method(:timeout) { ENV['TIMEOUT'] }
-  #   builder.build
+  #     builder = Sinclair.new(EnvFetcher)
   #
-  #   ENV['TIMEOUT'] = '300'
+  #     builder.add_class_method(:timeout, type: :block) { ENV['TIMEOUT'] }
+  #     builder.build
   #
-  #   env_fetcher.timeout # returns '300'
+  #     ENV['TIMEOUT'] = '300'
   #
-  # @return [Array<MethodDefinition>]
-  def add_class_method(name, code = nil, **options, &block)
-    class_definitions.add(
-      name, code, **options, &block
-    )
+  #     EnvFetcher.timeout # returns '300'
+  #
+  #   @example Passing type call
+  #     class EnvFetcher
+  #     end
+  #
+  #     builder = Sinclair.new(EnvFetcher)
+  #
+  #     builder.add_class_method(:attr_accessor, :timeout, type: :call)
+  #     builder.build
+  #
+  #     EnvFetcher.timeout = 10
+  #
+  #     env_fetcher.timeout # returns '10'
+  #
+  # @return [Array<MethodDefinition>] the list of all currently defined class methods
+  def add_class_method(*args, type: nil, **options, &block)
+    class_definitions.add(*args, type: type, **options, &block)
   end
 
   # Evaluetes a block which will result in a String, the method code
   #
   # @example Building a initial value class method
-  #
   #   module InitialValuer
   #     extend ActiveSupport::Concern
   #
@@ -301,6 +387,7 @@ class Sinclair
   #   end
   #
   #   object = MyClass.new
+  #
   #   object.age # 20
   #   object.age = 30
   #   object.age # 30
@@ -345,7 +432,7 @@ class Sinclair
   #   end
   #
   #   Purchase.new(2.3, 5).total_price # returns 11.5
-  # @return [Array<MethodDefinition>]
+  # @return [Array<MethodDefinition>] the list of all currently defined instance methods
   def eval_and_add_method(name, &block)
     add_method(name, instance_eval(&block))
   end