sinclair 1.10.0 → 1.12.0

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.12.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,61 @@
+# 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 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
+
+        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

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: false
+
+require 'spec_helper'
+
+describe 'yard Sinclair#add_method' do
+  describe 'Using string code to add a string defined method' do
+    let(:klass) { Class.new(Person) }
+
+    it 'creates new method' do
+      builder = Sinclair.new(klass)
+      builder.add_method(:full_name, '[first_name, last_name].join(" ")')
+      builder.build
+
+      expect(klass.new('john', 'wick').full_name).to eq('john wick')
+    end
+  end
+
+  describe 'Using block to add a block method' do
+    let(:klass) { Class.new(Person) }
+
+    it 'creates new method' do
+      builder = Sinclair.new(klass)
+      builder.add_method(:bond_name) { "#{last_name}, #{first_name} #{last_name}" }
+      builder.build
+
+      expect(klass.new('john', 'wick').bond_name).to eq('wick, john wick')
+    end
+  end
+
+  describe 'Passing type block' do
+    let(:klass) { Class.new(Person) }
+
+    it 'creates new method' do
+      builder = Sinclair.new(klass)
+      builder.add_method(:bond_name, type: :block, cached: true) do
+        "#{last_name}, #{first_name} #{last_name}"
+      end
+      builder.build
+      person = klass.new('john', 'wick')
+
+      expect(person.bond_name).to eq('wick, john wick')
+      person.first_name = 'Johny'
+      expect(person.bond_name).to eq('wick, john wick')
+    end
+  end
+
+  describe 'Passing type call' do
+    let(:klass) { Class.new }
+
+    it 'creates new method' do
+      builder = Sinclair.new(klass)
+      builder.add_method(:attr_accessor, :bond_name, type: :call)
+      builder.build
+      person = klass.new
+
+      person.bond_name = 'Bond, James Bond'
+      expect(person.bond_name).to eq('Bond, James Bond')
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: false
+
+require 'spec_helper'
+
+describe 'yard Sinclair#eval_and_add_method' do
+  describe 'Building a initial value class method' do
+    let(:klass) do
+      Class.new do
+        include InitialValuer
+        attr_writer :age
+
+        initial_value_for :age, 20
+      end
+    end
+
+    context 'when it has not been initialized' do
+      it do
+        object = klass.new
+
+        expect(object.age).to eq(20)
+        object.age = 30
+        expect(object.age).to eq(30)
+      end
+    end
+  end
+end

data/spec/integration/yard/sinclair_spec.rb

@@ -119,88 +119,5 @@ describe Sinclair do
         end
       end
     end
-
-    describe '#add_method' do
-      let(:klass) { Class.new(Person) }
-      let(:instance) { klass.new('john', 'wick') }
-
-      before do
-        builder.add_method(:full_name, '[first_name, last_name].join(" ")')
-        builder.add_method(:bond_name) { "#{last_name}, #{first_name} #{last_name}" }
-        builder.build
-      end
-
-      describe '#full_name' do
-        it 'returns the full name' do
-          expect(instance.full_name).to eq('john wick')
-        end
-      end
-
-      describe '#bond_name' do
-        it 'returns the full name, bond style' do
-          expect(instance.bond_name).to eq('wick, john wick')
-        end
-      end
-    end
-
-    describe '#add_class_method' do
-      let(:klass)       { env_fetcher }
-      let(:env_fetcher) { Class.new }
-
-      describe '#hostname' do
-        before do
-          builder.add_class_method(:hostname, 'ENV["HOSTNAME"]')
-          builder.build
-          ENV['HOSTNAME'] = 'myhost'
-        end
-
-        it 'returns the hostname' do
-          expect(env_fetcher.hostname).to eq('myhost')
-        end
-      end
-
-      describe '#timeout' do
-        before do
-          builder.add_class_method(:timeout) { ENV['TIMEOUT'] }
-          builder.build
-          ENV['TIMEOUT'] = '300'
-        end
-
-        it 'returns the timeout' do
-          expect(env_fetcher.timeout).to eq('300')
-        end
-      end
-    end
-
-    describe '#eval_and_add_method' do
-      subject(:builder) { klass.new }
-
-      let(:klass) do
-        Class.new do
-          include InitialValuer
-          attr_writer :age
-          initial_value_for :age, 20
-        end
-      end
-
-      describe '#age' do
-        context 'when it has not been initialized' do
-          it do
-            expect(builder.age).to eq(20)
-          end
-        end
-
-        context 'when it has been initialized' do
-          before do
-            builder.age
-            builder.age = 30
-          end
-
-          it do
-            expect(builder.age).to eq(30)
-          end
-        end
-      end
-    end
   end
 end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::MethodBuilder::Base do
+  describe '.build' do
+    let(:klass) { Class.new }
+    let(:type)  { Sinclair::MethodBuilder::CLASS_METHOD }
+
+    it do
+      expect { described_class.build(klass, instance_of(described_class), type: type) }
+        .to raise_error(NotImplementedError)
+    end
+  end
+end

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