sinclair 1.4.2 → 1.5.0

data/lib/sinclair/method_definition/block_definition.rb

@@ -17,71 +17,9 @@ class Sinclair
         super(name, **options)
       end
 
-      # Adds the instance method to given klass
-      #
-      # @param klass [Class] class which will receive the new method
-      #
-      # @see MethodDefinition#build
-      #
-      # @return [Symbol] name of the created method
-      #
-      # @example Using instance block method with cached options
-      #   class MyModel
-      #   end
-      #
-      #   instance = MyModel.new
-      #
-      #   method_definition = Sinclair::MethodDefinition::InstanceBlockDefinition.new(
-      #     :sequence, cached: true
-      #   ) do
-      #     @x = @x.to_i ** 2 + 1
-      #   end
-      #
-      #   method_definition.build(MyModel) # adds instance_method :sequence to
-      #                                    # MyModel instances
-      #
-      #   instance.instance_variable_get(:@sequence) # returns nil
-      #   instance.instance_variable_get(:@x)        # returns nil
-      #
-      #   instance.sequence               # returns 1
-      #   instance.sequence               # returns 1 (cached value)
-      #
-      #   instance.instance_variable_get(:@sequence) # returns 1
-      #   instance.instance_variable_get(:@x)        # returns 1
-      #
-      # @example Using class block method without options
-      #   class MyModel
-      #   end
-      #
-      #   method_definition = Sinclair::MethodDefinition::ClassBlockDefinition.new(:sequence) do
-      #     @x = @x.to_i ** 2 + 1
-      #   end
-      #
-      #   method_definition.build(MyModel)    # adds instance_method :sequence to
-      #                                       # MyModel instances
-      #
-      #   MyModel.instance_variable_get(:@x) # returns nil
-      #
-      #   MyModel.sequence                   # returns 1
-      #   MyModel.sequence                   # returns 2
-      #   MyModel.sequence                   # returns 5
-      #
-      #   MyModel.instance_variable_get(:@x) # returns 5
-      def build(klass)
-        klass.send(method_definer, name, method_block)
-      end
-
-      private
+      default_value :block?, true
+      default_value :string?, false
 
-      # @method block
-      # @private
-      #
-      # Block with code to be added as method
-      # @return [Proc]
-      attr_reader :block
-
-      # @private
-      #
       # Returns the block that will be used for method creattion
       #
       # @return [Proc]
@@ -90,44 +28,20 @@ class Sinclair
 
         case cached
         when :full
-          full_cached_method_proc(name, block)
+          BlockHelper.full_cached_method_proc(name, &block)
         else
-          cached_method_proc(name, block)
+          BlockHelper.cached_method_proc(name, &block)
         end
       end
 
-      # @private
-      #
-      # Returns proc block when {#cached?} as simple
-      #
-      # @return [Proc]
-      def cached_method_proc(method_name, inner_block)
-        proc do
-          instance_variable_get("@#{method_name}") ||
-            instance_variable_set(
-              "@#{method_name}",
-              instance_eval(&inner_block)
-            )
-        end
-      end
+      private
 
+      # @method block
       # @private
       #
-      # Returns proc block when {#cached?} as full
-      #
+      # Block with code to be added as method
       # @return [Proc]
-      def full_cached_method_proc(method_name, inner_block)
-        proc do
-          if instance_variable_defined?("@#{method_name}")
-            instance_variable_get("@#{method_name}")
-          else
-            instance_variable_set(
-              "@#{method_name}",
-              instance_eval(&inner_block)
-            )
-          end
-        end
-      end
+      attr_reader :block
     end
   end
 end

data/lib/sinclair/method_definition/block_helper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Sinclair
+  class MethodDefinition
+    # @api private
+    # @author darthjee
+    #
+    # Helper for wrapping block with cacheing
+    module BlockHelper
+      module_function
+
+      # @private
+      #
+      # Returns proc block when {#cached?} as simple
+      #
+      # @return [Proc]
+      def cached_method_proc(method_name, &inner_block)
+        proc do
+          instance_variable_get("@#{method_name}") ||
+            instance_variable_set(
+              "@#{method_name}",
+              instance_eval(&inner_block)
+            )
+        end
+      end
+
+      # @private
+      #
+      # Returns proc block when {#cached?} as full
+      #
+      # @return [Proc]
+      def full_cached_method_proc(method_name, &inner_block)
+        proc do
+          if instance_variable_defined?("@#{method_name}")
+            instance_variable_get("@#{method_name}")
+          else
+            instance_variable_set(
+              "@#{method_name}",
+              instance_eval(&inner_block)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sinclair/method_definition/string_definition.rb

@@ -19,58 +19,14 @@ class Sinclair
         super(name, **options)
       end
 
-      # Adds the method to given klass
-      #
-      # @param klass [Class] class which will receive the new method
-      #
-      # @see MethodDefinition#build
-      #
-      # @return [Symbol] name of the created method
-      #
-      # @example Using instance string method with no options
-      #   class MyModel
-      #   end
-      #
-      #   instance = MyModel.new
-      #
-      #   method_definition = Sinclair::MethodDefinition::InstanceStringDefinition.new(
-      #     :sequence, '@x = @x.to_i ** 2 + 1'
-      #   )
-      #
-      #   method_definition.build(MyModel)    # adds instance_method :sequence to
-      #                                       # MyModel instances
-      #
-      #   instance.instance_variable_get(:@x) # returns nil
-      #
-      #   instance.sequence                   # returns 1
-      #   instance.sequence                   # returns 2
-      #   instance.sequence                   # returns 5
-      #
-      #   instance.instance_variable_get(:@x) # returns 5
-      #
-      # @example Using class string method with cache options
-      #   class MyModel
-      #   end
-      #
-      #   method_definition = Sinclair::MethodDefinition::ClassStringDefinition.new(
-      #     :sequence,
-      #     '@x = @x.to_i ** 2 + 1',
-      #     cached: true
-      #   )
-      #
-      #   method_definition.build(MyModel) # adds instance_method :sequence to
-      #                                    # MyModel instances
-      #
-      #   MyModel.instance_variable_get(:@sequence) # returns nil
-      #   MyModel.instance_variable_get(:@x)        # returns nil
-      #
-      #   MyModel.sequence               # returns 1
-      #   MyModel.sequence               # returns 1 (cached value)
+      default_value :block?, false
+      default_value :string?, true
+
+      # codeline to be run inside the code
       #
-      #   MyModel.instance_variable_get(:@sequence) # returns 1
-      #   MyModel.instance_variable_get(:@x)        # returns 1
-      def build(klass)
-        klass.module_eval(code_definition, __FILE__, __LINE__ + 1)
+      # @return [String]
+      def code_line
+        cached? ? code_with_cache : code
       end
 
       private
@@ -83,21 +39,6 @@ class Sinclair
       # @return [String]
       attr_reader :code
 
-      # @private
-      #
-      # Builds full code of method
-      #
-      # @return [String]
-      def code_definition
-        code_line = cached? ? code_with_cache : code
-
-        <<-CODE
-          def #{method_name}
-            #{code_line}
-          end
-        CODE
-      end
-
       # @private
       #
       # Returns string code when {#cached?}

data/lib/sinclair/method_definitions.rb

@@ -5,10 +5,11 @@ class Sinclair
   # @author darthjee
   #
   # Enumerator holding all method definitions
-  class MethodDefinitions < Array
+  class MethodDefinitions
+    delegate :each, to: :definitions
+
     # Builds and adds new definition
     #
-    # @param definition_class [Class] class used to define method definition
     # @param name [String,Symbol] method name
     # @param options [Hash] Options of construction
     # @option options cached [Boolean] Flag telling to create
@@ -21,8 +22,19 @@ class Sinclair
     #   @param block [Proc]  block to be ran as method
     #
     # @return MethodDefinitions
-    def add(definition_class, name, code = nil, **options, &block)
-      self << definition_class.from(name, code, **options, &block)
+    def add(name, code = nil, **options, &block)
+      definitions << MethodDefinition.from(name, code, **options, &block)
+    end
+
+    private
+
+    # @private
+    #
+    # All definitions
+    #
+    # @return [Array<MethodDefinition>]
+    def definitions
+      @definitions ||= []
     end
   end
 end

data/lib/sinclair/version.rb

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

data/sinclair.gemspec

@@ -35,6 +35,6 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rubocop-rspec',      '1.33.0'
   gem.add_development_dependency 'rubycritic',         '4.1.0'
   gem.add_development_dependency 'simplecov',          '0.17.0'
-  gem.add_development_dependency 'yard',               '0.9.19'
+  gem.add_development_dependency 'yard',               '0.9.20'
   gem.add_development_dependency 'yardstick',          '0.9.9'
 end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::MethodBuilder::BlockMethodBuilder do
+  describe '#build' do
+    subject(:builder) do
+      described_class.new(klass, definition, type: type)
+    end
+
+    let(:klass)       { Class.new }
+    let(:instance)    { klass.new }
+    let(:value)       { Random.rand }
+    let(:method_name) { :the_method }
+
+    let(:definition) do
+      result = value
+      Sinclair::MethodDefinition.from(method_name) { result }
+    end
+
+    context 'when type is instance' do
+      let(:type) { Sinclair::MethodBuilder::INSTANCE_METHOD }
+
+      it do
+        expect { builder.build }
+          .to add_method(method_name).to(instance)
+      end
+
+      context 'when the method is built' do
+        before { builder.build }
+
+        it 'returns the result of the block when called' do
+          expect(instance.the_method).to eq(value)
+        end
+      end
+    end
+
+    context 'when type is class' do
+      let(:type) { Sinclair::MethodBuilder::CLASS_METHOD }
+
+      it do
+        expect { builder.build }
+          .to add_class_method(method_name).to(klass)
+      end
+
+      context 'when the method is built' do
+        before { builder.build }
+
+        it 'returns the result of the block when called' do
+          expect(klass.the_method).to eq(value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::MethodBuilder::StringMethodBuilder do
+  describe '#build' do
+    subject(:builder) do
+      described_class.new(klass, definition, type: type)
+    end
+
+    let(:klass)       { Class.new }
+    let(:instance)    { klass.new }
+    let(:value)       { Random.rand }
+    let(:method_name) { :the_method }
+
+    let(:definition) do
+      Sinclair::MethodDefinition.from(method_name, value.to_s)
+    end
+
+    context 'when type is instance' do
+      let(:type) { Sinclair::MethodBuilder::INSTANCE_METHOD }
+
+      it do
+        expect { builder.build }
+          .to add_method(method_name).to(instance)
+      end
+
+      context 'when the method is built' do
+        before { builder.build }
+
+        it 'returns the result of the code when called' do
+          expect(instance.the_method).to eq(value)
+        end
+      end
+    end
+
+    context 'when type is class' do
+      let(:type) { Sinclair::MethodBuilder::CLASS_METHOD }
+
+      it do
+        expect { builder.build }
+          .to add_class_method(method_name).to(klass)
+      end
+
+      context 'when the method is built' do
+        before { builder.build }
+
+        it 'returns the result of the code when called' do
+          expect(klass.the_method).to eq(value)
+        end
+      end
+    end
+  end
+end

data/spec/lib/sinclair/method_builder_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::MethodBuilder do
+  subject(:builder) { described_class.new(klass) }
+
+  let(:klass)       { Class.new }
+  let(:definitions) { Sinclair::MethodDefinitions.new }
+  let(:value)       { Random.rand }
+  let(:method_name) { :the_method }
+  let(:instance)    { klass.new }
+
+  before do
+    definitions.add(method_name, value.to_s)
+  end
+
+  describe '#build_methods' do
+    context 'when building an instance method' do
+      let(:type) { described_class::INSTANCE_METHOD }
+
+      it do
+        expect { builder.build_methods(definitions, type) }
+          .to add_method(method_name).to(instance)
+      end
+
+      context 'when the method is called' do
+        before { builder.build_methods(definitions, type) }
+
+        it do
+          expect(instance.the_method).to eq(value)
+        end
+      end
+    end
+
+    context 'when building a class method' do
+      let(:type) { described_class::INSTANCE_METHOD }
+
+      it do
+        expect { builder.build_methods(definitions, type) }
+          .to add_method(method_name).to(instance)
+      end
+
+      context 'when the method is called' do
+        before { builder.build_methods(definitions, type) }
+
+        it do
+          expect(instance.the_method).to eq(value)
+        end
+      end
+    end
+  end
+end