sinclair 1.9.0 → 1.11.0

data/lib/sinclair/method_definition/call_definition.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class Sinclair
+  class MethodDefinition
+    # @api private
+    # @author darthjee
+    #
+    # 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
+      def initialize(method_name, *arguments)
+        @arguments = arguments
+        super(method_name)
+      end
+
+      default_value :block?, false
+      default_value :string?, false
+
+      # Block to be evaluated by the class when adding methods
+      #
+      # 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
+      #
+      # Arguments to be passed when calling the method inside the block
+      #
+      # @return [Array<Object>]
+    end
+  end
+end

data/lib/sinclair/method_definition/string_definition.rb

@@ -5,10 +5,10 @@ class Sinclair
     # @api private
     # @author darthjee
     #
-    # @abstract
-    #
     # 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

@@ -12,6 +12,8 @@ class Sinclair
     autoload :BlockDefinition,  'sinclair/method_definition/block_definition'
     autoload :StringDefinition, 'sinclair/method_definition/string_definition'
 
+    autoload :CallDefinition, 'sinclair/method_definition/call_definition'
+
     # @method name
     #
     # name of the method
@@ -24,31 +26,80 @@ class Sinclair
       cached: false
     }.freeze
 
-    # Builds a method that will return the same value always
-    #
-    # @return [Symbol]
-    def self.default_value(method_name, value)
-      define_method(method_name) { value }
-    end
+    class << self
+      # Builds a method that will return the same value always
+      #
+      # @return [Symbol]
+      def default_value(method_name, value)
+        define_method(method_name) { value }
+      end
 
-    # @param name    [String,Symbol] name of the method
-    # @param code    [String] code to be evaluated as method
-    # @param block   [Proc] block with code to be added as method
-    # @param options [Hash] Options of construction
-    # @option options cached [Boolean] Flag telling to create a block
-    #   with cache
-    #
-    # builds a method definition based on arguments
-    #
-    # when block is given, returns a {BlockDefinition} and
-    # returns a {StringDefinition} otherwise
-    #
-    # @return [Base]
-    def self.from(name, code = nil, **options, &block)
-      if block
-        BlockDefinition.new(name, **options, &block)
-      else
-        StringDefinition.new(name, code, **options)
+      # @param name    [String,Symbol] name of the method
+      # @param code    [String] code to be evaluated as method
+      # @param block   [Proc] block with code to be added as method
+      # @param options [Hash] Options of construction
+      # @option options cached [Boolean] Flag telling to create a block
+      #   with cache
+      #
+      # builds a method definition based on arguments
+      #
+      # when block is given, returns a {BlockDefinition} and
+      # returns a {StringDefinition} otherwise
+      #
+      # @return [Base]
+      def from(name, code = nil, **options, &block)
+        if block
+          BlockDefinition.new(name, **options, &block)
+        else
+          StringDefinition.new(name, code, **options)
+        end
+      end
+
+      # creates a definition
+      #
+      # 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
 
@@ -71,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

@@ -10,20 +10,38 @@ class Sinclair
 
     # Builds and adds new definition
     #
-    # @param name [String,Symbol] method name
-    # @param options [Hash] Options of construction
-    # @option options cached [Boolean] Flag telling to create
-    #   a method with cache
+    # The type is decided based in the arguments
     #
     # @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 MethodDefinitions
-    def add(name, code = nil, **options, &block)
-      definitions << MethodDefinition.from(name, code, **options, &block)
+    # @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
+    #
+    # @see MethodDefinition.for
+    # @see MethodDefinition.from
+    #
+    # @return [Array<MethodDefinition>]
+    def add(*args, type: nil, **options, &block)
+      definitions << MethodDefinition.for(type, *args, **options, &block)
     end
 
     private

data/lib/sinclair/options/builder.rb

@@ -36,6 +36,7 @@ class Sinclair
       # @return (see Sinclair#build)
       def build
         add_all_methods
+        add_filds_to_equals
 
         super
       end
@@ -60,6 +61,13 @@ class Sinclair
           klass.allow(option)
         end
       end
+
+      # Add the fields to equals comparation
+      #
+      # @return (see Sinclair::EqualsChecker#add)
+      def add_filds_to_equals
+        klass.comparable_by(*attributes.keys)
+      end
     end
   end
 end

data/lib/sinclair/options.rb

@@ -24,6 +24,7 @@ class Sinclair
     autoload :ClassMethods, 'sinclair/options/class_methods'
 
     extend ClassMethods
+    include Comparable
 
     # @param options [Hash] hash with options (see {.options}, {.with_options})
     # @example (see Options)
@@ -59,19 +60,6 @@ class Sinclair
       end
     end
 
-    # returns if other equals to self
-    #
-    # @param other [Object] object to be compared
-    #
-    # @return [TrueClass,FalseClass]
-    def ==(other)
-      return false unless self.class == other.class
-
-      allowed_options.all? do |name|
-        public_send(name) == other.public_send(name)
-      end
-    end
-
     private
 
     delegate :allowed_options, :skip_validation?, :invalid_options_in, to: :class

data/lib/sinclair/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Sinclair
-  VERSION = '1.9.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

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair do
+  describe 'README' do
+    describe 'Define method using block' do
+      it 'adds the method' do
+        klass = Class.new
+        instance = klass.new
+
+        builder = described_class.new(klass)
+        builder.add_method(:random_number) { Random.rand(10..20) }
+        builder.build
+
+        expect(instance.random_number).to be_between(10, 20)
+      end
+    end
+
+    describe 'Define method using string' do
+      it 'adds the method' do
+        klass = Class.new
+        instance = klass.new
+
+        builder = described_class.new(klass)
+        builder.add_method(:random_number, 'Random.rand(10..20)')
+        builder.build
+
+        expect(instance.random_number).to be_between(10, 20)
+      end
+    end
+
+    describe 'Define method using call to the class' do
+      it 'performs the call to the class' do
+        klass = Class.new
+
+        builder = described_class.new(klass)
+        builder.add_class_method(:attr_accessor, :number, type: :call)
+        builder.build
+
+        expect(klass.number).to be_nil
+        klass.number = 10
+        expect(klass.number).to eq(10)
+      end
+    end
+  end
+end

data/spec/integration/yard/sinclair/add_class_method_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: false
+
+require 'spec_helper'
+
+describe 'yard Sinclair#add_class_method' do
+  let(:klass) { Class.new }
+
+  describe 'Adding a method by String' do
+    it 'returns the hostname' do
+      builder = Sinclair.new(klass)
+      builder.add_class_method(:hostname, 'ENV["HOSTNAME"]')
+      builder.build
+      ENV['HOSTNAME'] = 'myhost'
+
+      expect(klass.hostname).to eq('myhost')
+    end
+  end
+
+  describe 'Adding a method by Block' do
+    it 'returns the timeout' do
+      builder = Sinclair.new(klass)
+      builder.add_class_method(:timeout) { ENV['TIMEOUT'] }
+      builder.build
+      ENV['TIMEOUT'] = '300'
+
+      expect(klass.timeout).to eq('300')
+    end
+  end
+
+  describe 'Passing type block' do
+    it 'creates new method' do
+      builder = Sinclair.new(klass)
+      builder.add_class_method(:timeout, type: :block) { ENV['TIMEOUT'] }
+      builder.build
+      ENV['TIMEOUT'] = '300'
+
+      expect(klass.timeout).to eq('300')
+    end
+  end
+
+  describe 'Passing type call' do
+    it 'creates new method' do
+      builder = Sinclair.new(klass)
+      builder.add_class_method(:attr_accessor, :timeout, type: :call)
+      builder.build
+
+      klass.timeout = 10
+      expect(klass.timeout).to eq(10)
+    end
+  end
+end