sinclair 1.1.3 → 1.2.0

data/lib/sinclair/method_definition.rb

@@ -6,30 +6,82 @@ class Sinclair
   #
   # Definition of the code or block to be aded as method
   class MethodDefinition
+    include Sinclair::OptionsParser
+    # Default options of initialization
+    DEFAULT_OPTIONS = {
+      cached: false
+    }.freeze
+
     # Returns a new instance of MethodDefinition
     #
     # @overload initialize(name, code)
-    # @overload initialize(name, &block)
+    #   @example
+    #     Sinclair::MethodDefinition.new(:name, '@name')
     #
-    # @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
-    #
-    # @example
-    #   Sinclair::Method.new(:name, '@name')
+    # @overload initialize(name, &block)
+    #   @example
+    #     Sinclair::MethodDefinition.new(:name) { @name }
     #
-    # @example
-    #   Sinclair::Method.new(:name) { @name }
-    def initialize(name, code = nil, &block)
-      @name = name
-      @code = code
-      @block = block
+    # @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 method with cache
+    def initialize(name, code = nil, **options, &block)
+      @name =    name
+      @code =    code
+      @options = DEFAULT_OPTIONS.merge(options)
+      @block =   block
     end
 
     # Adds the method to given klass
     #
     # @param klass [Class] class which will receive the new method
     #
+    # @example Using string method with no options
+    #   class MyModel
+    #   end
+    #
+    #   instance = MyModel.new
+    #
+    #   method_definition = Sinclair::MethodDefinition.new(
+    #     :sequence, '@x = @x.to_i ** 2 + 1'
+    #   )
+    #
+    #   method_definition.build(klass)  # 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 string method with no options
+    #   class MyModel
+    #   end
+    #
+    #   instance = MyModel.new
+    #
+    #   method_definition = Sinclair::MethodDefinition.new(:sequence) do
+    #     @x = @x.to_i ** 2 + 1
+    #   end
+    #
+    #   method_definition.build(klass)  # 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
+    #
     # @return [Symbol] name of the created method
     def build(klass)
       if code.is_a?(String)
@@ -43,6 +95,14 @@ class Sinclair
 
     # @private
     attr_reader :name, :code, :block
+    delegate :cached, to: :options_object
+
+    # @private
+    #
+    # Flag telling to use cached method
+    #
+    # @return [Boolean]
+    alias cached? cached
 
     # @private
     #
@@ -50,7 +110,27 @@ class Sinclair
     #
     # @return [Symbol] name of the created method
     def build_block_method(klass)
-      klass.send(:define_method, name, block)
+      klass.send(:define_method, name, method_block)
+    end
+
+    # @private
+    #
+    # Returns the block that will be used for method creattion
+    #
+    # @return [Proc]
+    def method_block
+      return block unless cached?
+
+      inner_block = block
+      method_name = name
+
+      proc do
+        instance_variable_get("@#{method_name}") ||
+          instance_variable_set(
+            "@#{method_name}",
+            instance_eval(&inner_block)
+          )
+      end
     end
 
     # @private
@@ -68,9 +148,10 @@ class Sinclair
     #
     # @return [String]
     def code_definition
+      code_line = cached? ? "@#{name} ||= #{code}" : code
       <<-CODE
       def #{name}
-        #{code}
+        #{code_line}
       end
       CODE
     end

data/lib/sinclair/version.rb

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

data/spec/integration/readme/my_class_spec.rb

@@ -3,10 +3,11 @@
 require 'spec_helper'
 
 describe MyClass do
-  subject { klass.new(attributes) }
-  let(:klass) { MyClass }
-  let(:name) { 'name' }
-  let(:age) { 20 }
+  subject(:model) { klass.new(attributes) }
+
+  let(:klass) { described_class }
+  let(:name)  { 'name' }
+  let(:age)   { 20 }
   let(:attributes) do
     {
       name: name,
@@ -18,34 +19,36 @@ describe MyClass do
 
   %i[name surname age legs].each do |field|
     it do
-      expect(subject).to respond_to(field)
+      expect(model).to respond_to(field)
     end
 
     it do
-      expect(subject).to respond_to("#{field}_valid?")
+      expect(model).to respond_to("#{field}_valid?")
     end
   end
 
   it do
-    expect(subject).to respond_to(:valid?)
+    expect(model).to respond_to(:valid?)
   end
 
   describe '#valid?' do
     it do
-      expect(subject).to be_valid
+      expect(model).to be_valid
     end
 
     context 'when a string attribute is a symbol' do
       let(:name) { :name }
+
       it do
-        expect(subject).not_to be_valid
+        expect(model).not_to be_valid
       end
     end
 
     context 'when an attribute is nil' do
       let(:age) { nil }
+
       it do
-        expect(subject).not_to be_valid
+        expect(model).not_to be_valid
       end
     end
   end

data/spec/integration/readme/my_model_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe MyModel do
+  subject(:model) { klass.new }
+
+  let(:klass)   { Class.new(described_class) }
+  let(:builder) { Sinclair.new(klass) }
+
+  before do
+    klass.send(:attr_accessor, :base, :expoent)
+
+    builder.add_method(:cached_power, cached: true) do
+      base**expoent
+    end
+
+    builder.build
+
+    model.base    = 3
+    model.expoent = 2
+  end
+
+  it 'caches the result of the method' do
+    expect { model.expoent = 3 }
+      .not_to change(model, :cached_power)
+    expect(model.cached_power).to eq(9)
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Sinclair::Matchers do
+  let(:klass)         { Class.new }
+  let(:method)        { :the_method }
+  let(:value)         { Random.rand(100) }
+  let(:builder_class) { DefaultValue }
+  let(:builder)       { builder_class.new(klass, method, value) }
+  let(:instance)      { klass.new }
+
+  context 'when the builder runs' do
+    it do
+      expect { builder.build }.to add_method(method).to(instance)
+    end
+  end
+
+  context 'when the builder runs' do
+    it do
+      expect { builder.build }.to add_method(method).to(klass)
+    end
+  end
+end

data/spec/integration/readme/sinclair_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair do
+  describe 'Stand Alone' do
+    let(:instance) { klass.new }
+    let(:klass)    { Class.new }
+    let(:builder)  { described_class.new(klass) }
+
+    before do
+      builder.add_method(:twenty, '10 + 10')
+      builder.add_method(:eighty) { 4 * twenty }
+      builder.build
+    end
+
+    it 'knows how to add string defined methods' do
+      expect("Twenty => #{instance.twenty}").to eq('Twenty => 20')
+    end
+
+    it 'knows how to add block defined methods' do
+      expect("Eighty => #{instance.eighty}").to eq('Eighty => 80')
+    end
+  end
+end

data/spec/integration/{matcher_spec.rb → sinclair/matchers_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe 'matchers' do
+describe Sinclair::Matchers do
   describe 'add_method_to' do
     let(:method)   { :the_method }
     let(:klass)    { Class.new }
@@ -83,15 +83,15 @@ describe 'matchers' do
       expect { block.call }.to add_method(method)
     end
     let(:block) { proc { klass.send(:define_method, method) {} } }
+    let(:expected_error) do
+      'You should specify which instance the method is being added to' \
+        "add_method(:#{method}).to(instance)"
+    end
 
     context 'when not calling to' do
       it 'raises error' do
-        expect do
-          expectation
-        end.to raise_error(
-          SyntaxError,
-          'You should specify which instance the method is being added to' \
-          "add_method(:#{method}).to(instance)"
+        expect { expectation }.to raise_error(
+          SyntaxError, expected_error
         )
       end
     end

data/spec/integration/yard/my_builder_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe MyBuilder do
+  describe '#yard' do
+    subject(:builder) do
+      described_class.new(klass, rescue_error: true)
+    end
+
+    let(:klass)    { Class.new }
+    let(:instance) { klass.new }
+
+    describe '#build' do
+      before do
+        builder.add_methods
+        builder.build
+      end
+
+      context 'when calling built method' do
+        it 'returns default value' do
+          expect(instance.symbolize).to eq(:default)
+        end
+      end
+    end
+  end
+end

data/spec/integration/yard/{matchers → sinclair/matchers}/add_method_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 RSpec.describe Sinclair::Matchers::AddMethod do
   describe 'yard' do
     describe '#to' do
-      context 'checking against Class' do
+      context 'when checking against Class' do
         let(:clazz)   { Class.new }
         let(:builder) { Sinclair.new(clazz) }
 
@@ -18,7 +18,7 @@ RSpec.describe Sinclair::Matchers::AddMethod do
         end
       end
 
-      context 'checking against instance' do
+      context 'when checking against instance' do
         let(:clazz)    { Class.new }
         let(:builder)  { Sinclair.new(clazz) }
         let(:instance) { clazz.new }

data/spec/integration/yard/{matchers → sinclair/matchers}/add_method_to_spec.rb

@@ -2,8 +2,8 @@
 
 require 'spec_helper'
 
-describe 'yard' do
-  describe Sinclair::Matchers::AddMethodTo do
+describe Sinclair::Matchers::AddMethodTo do
+  describe 'yard' do
     let(:klass)   { Class.new(MyModel) }
     let(:builder) { Sinclair.new(klass) }
 

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+describe Sinclair::MethodDefinition do
+  describe 'yard' do
+    describe '#build' do
+      describe 'using string method with no options' do
+        subject(:method_definition) do
+          described_class.new(name, code)
+        end
+
+        let(:klass)    { Class.new }
+        let(:instance) { klass.new }
+        let(:code)     { '@x = @x.to_i ** 2 + 1' }
+        let(:name)     { :sequence }
+
+        it 'adds a dynamic method' do
+          expect { method_definition.build(klass) }.to add_method(name).to(instance)
+          expect { instance.sequence }
+            .to change { instance.instance_variable_get(:@x) }.from(nil).to 1
+          expect(instance.sequence).to eq(2)
+          expect(instance.sequence).to eq(5)
+        end
+
+        it 'changes instance variable' do
+          method_definition.build(klass)
+
+          expect { instance.sequence }
+            .to change { instance.instance_variable_get(:@x) }
+            .from(nil).to 1
+        end
+      end
+
+      describe 'using block with cache option' do
+        subject(:method_definition) do
+          described_class.new(name, cached: true) do
+            @x = @x.to_i**2 + 1
+          end
+        end
+
+        let(:klass)    { Class.new }
+        let(:instance) { klass.new }
+        let(:name)     { :sequence }
+
+        it 'adds a dynamic method' do
+          expect { method_definition.build(klass) }.to add_method(name).to(instance)
+          expect { instance.sequence }
+            .to change { instance.instance_variable_get(:@x) }.from(nil).to 1
+          expect { instance.sequence }.not_to change(instance, :sequence)
+          expect(instance.instance_variable_get(:@sequence)).to eq(1)
+        end
+      end
+    end
+  end
+end