sinclair 1.3.0 → 1.3.1

data/lib/sinclair/method_definition/block_definition.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+class Sinclair
+  class MethodDefinition
+    # Define a method from block
+    class BlockDefinition < MethodDefinition
+      # @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
+      # @option options cached [Boolean] Flag telling to create
+      #   a method with cache
+      def initialize(name, **options, &block)
+        @block = block
+        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 block method with no options
+      #   class MyModel
+      #   end
+      #
+      #   instance = MyModel.new
+      #
+      #   method_definition = Sinclair::MethodDefinition::BlockDefinition.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
+      def build(klass)
+        klass.send(:define_method, name, method_block)
+      end
+
+      private
+
+      # @private
+      #
+      # Returns the block that will be used for method creattion
+      #
+      # @return [Proc]
+      def method_block
+        return block unless cached?
+
+        case cached
+        when :full
+          full_cached_method_proc(name, block)
+        else
+          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
+      #
+      # 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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+class Sinclair
+  class MethodDefinition
+    # Define a method from string
+    class StringDefinition < MethodDefinition
+      # @param name    [String,Symbol] name of the method
+      # @param code    [String] code to be evaluated 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)
+        @code = code
+        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 With no options
+      #   class MyModel
+      #   end
+      #
+      #   instance = MyModel.new
+      #
+      #   method_definition = Sinclair::MethodDefinition.from(
+      #     :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
+      #
+      def build(klass)
+        klass.module_eval(code_definition, __FILE__, __LINE__ + 1)
+      end
+
+      private
+
+      # @private
+      #
+      # Builds full code of method
+      #
+      # @return [String]
+      def code_definition
+        code_line = cached? ? code_with_cache : code
+
+        <<-CODE
+          def #{name}
+            #{code_line}
+          end
+        CODE
+      end
+
+      # @private
+      #
+      # Returns string code when {#cached?}
+      #
+      # @return [String]
+      def code_with_cache
+        case cached
+        when :full
+          "defined?(@#{name}) ? @#{name} : (@#{name} = #{code})"
+        else
+          "@#{name} ||= #{code}"
+        end
+      end
+    end
+  end
+end

data/lib/sinclair/version.rb

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

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Configurable do
+  context 'when it is configured' do
+    before do
+      MyConfigurable.configure do |config|
+        config.host 'interstella.art'
+        config.port 5555
+      end
+    end
+
+    after do
+      MyConfigurable.reset_config
+    end
+
+    it 'sets configuration host' do
+      expect(MyConfigurable.config.host)
+        .to eq('interstella.art')
+    end
+
+    it 'sets configuration port' do
+      expect(MyConfigurable.config.port)
+        .to eq(5555)
+    end
+
+    context 'when #rest_config is called' do
+      before do
+        MyConfigurable.reset_config
+      end
+
+      it 'resets configuration host' do
+        expect(MyConfigurable.config.host)
+          .to be_nil
+      end
+
+      it 'resets configuration port' do
+        expect(MyConfigurable.config.port)
+          .to be_nil
+      end
+    end
+  end
+end

data/spec/integration/readme/sinclair_spec.rb

@@ -22,4 +22,74 @@ describe Sinclair do
       expect("Eighty => #{instance.eighty}").to eq('Eighty => 80')
     end
   end
+
+  describe 'Stand Alone concern' do
+    subject(:person) { HttpPerson.new(json) }
+
+    let(:json) do
+      <<-JSON
+        {
+          "uid": "12sof511",
+          "personal_information":{
+            "name":"Bob",
+            "age": 21
+          },
+          "digital_information":{
+            "username":"lordbob",
+            "email":"lord@bob.com"
+          }
+        }
+      JSON
+    end
+
+    it 'adds uid method' do
+      expect(person.uid).to eq('12sof511')
+    end
+
+    it 'adds name method' do
+      expect(person.name).to eq('Bob')
+    end
+
+    it 'adds age method' do
+      expect(person.age).to eq(21)
+    end
+
+    it 'adds username method' do
+      expect(person.username).to eq('lordbob')
+    end
+
+    it 'adds email method' do
+      expect(person.email).to eq('lord@bob.com')
+    end
+  end
+
+  describe 'DefaultValuable' do
+    subject(:server) { Server.new }
+
+    it 'returns default url' do
+      expect(server.url).to eq('http://server.com:80')
+    end
+
+    context 'when new values are set' do
+      before do
+        server.host = 'interstella.com'
+        server.port = 5555
+      end
+
+      it 'returns custom url' do
+        expect(server.url).to eq('http://interstella.com:5555')
+      end
+
+      context 'when values are nullified' do
+        before do
+          server.host = nil
+          server.port = nil
+        end
+
+        it 'returns url with default + custom nil values' do
+          expect(server.url).to eq('http://server.com')
+        end
+      end
+    end
+  end
 end

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

@@ -9,6 +9,10 @@ describe Sinclair::Configurable do
       end
     end
 
+    after do
+      MyConfigurable.reset_config
+    end
+
     it 'sets right value for config host' do
       expect(MyConfigurable.config.host)
         .to eq('interstella.com')

data/spec/integration/yard/sinclair/method_definition/block_definition_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+describe Sinclair::MethodDefinition::BlockDefinition do
+  describe 'yard' do
+    describe '#build' do
+      subject(:method_definition) do
+        described_class.from(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

data/spec/integration/yard/sinclair/method_definition/string_definition_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+describe Sinclair::MethodDefinition::StringDefinition do
+  describe 'yard' do
+    describe '#build' 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
+  end
+end

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

@@ -5,7 +5,7 @@ describe Sinclair::MethodDefinition do
     describe '#build' do
       describe 'using string method with no options' do
         subject(:method_definition) do
-          described_class.new(name, code)
+          described_class.from(name, code)
         end
 
         let(:klass)    { Class.new }
@@ -32,7 +32,7 @@ describe Sinclair::MethodDefinition do
 
       describe 'using block with cache option' do
         subject(:method_definition) do
-          described_class.new(name, cached: true) do
+          described_class.from(name, cached: true) do
             @x = @x.to_i**2 + 1
           end
         end

data/spec/integration/yard/sinclair_spec.rb

@@ -9,6 +9,36 @@ describe Sinclair do
     let(:builder)       { described_class.new(klass) }
     let(:default_value) { 10 }
 
+    describe 'Using cache' do
+      subject(:server) { Server.new }
+
+      it 'returns default url' do
+        expect(server.url).to eq('http://server.com:80')
+      end
+
+      context 'when new values are set' do
+        before do
+          server.host = 'interstella.com'
+          server.port = 5555
+        end
+
+        it 'returns custom url' do
+          expect(server.url).to eq('http://interstella.com:5555')
+        end
+
+        context 'when values are nullified' do
+          before do
+            server.host = nil
+            server.port = nil
+          end
+
+          it 'returns url with default + custom nil values' do
+            expect(server.url).to eq('http://server.com')
+          end
+        end
+      end
+    end
+
     describe '#initialize' do
       describe '#total_price' do
         before do

data/spec/lib/sinclair/matchers/add_method_to_spec.rb

@@ -39,6 +39,16 @@ describe Sinclair::Matchers::AddMethodTo do
         it { expect(matcher).to be_matches(event_proc) }
       end
     end
+
+    context 'when a block is given' do
+      it do
+        expect { matcher.matches?(event_proc) { 1 } }
+          .to raise_error(
+            SyntaxError, 'Block not received by the `add_method_to` matcher. ' \
+          'Perhaps you want to use `{ ... }` instead of do/end?'
+          )
+      end
+    end
   end
 
   describe '#failure_message_for_should' do