sinclair 1.1.3 → 1.2.0

data/spec/integration/yard/{options_parser_spec.rb → sinclair/options_parser_spec.rb}

@@ -2,14 +2,15 @@
 
 require 'spec_helper'
 
-describe 'yard' do
-  describe Sinclair::OptionsParser do
+describe Sinclair::OptionsParser do
+  describe 'yard' do
+    subject(:model) { described_class::Dummy.new(options) }
+
     let(:options) { { switch: false, option_1: 10, option_2: 20 } }
-    subject { described_class::Dummy.new(options) }
 
     describe '#the_method' do
       it 'returns the value for option given' do
-        expect(subject.the_method).to eq('The value is not 10 but 20')
+        expect(model.the_method).to eq('The value is not 10 but 20')
       end
     end
   end

data/spec/integration/yard/sinclair_spec.rb

@@ -2,27 +2,27 @@
 
 require 'spec_helper'
 
-describe 'yarn' do
-  describe Sinclair do
-    let(:klass)    { Class.new(MyModel) }
-    let(:instance) { klass.new }
-    let(:builder)  { Sinclair.new(klass) }
+describe Sinclair do
+  describe 'yarn' do
+    let(:klass)         { Class.new(MyModel) }
+    let(:instance)      { klass.new }
+    let(:builder)       { described_class.new(klass) }
     let(:default_value) { 10 }
 
     describe '#initialize' do
       describe '#total_price' do
         before do
-          subject.eval_and_add_method(:total_price) do
+          builder.eval_and_add_method(:total_price) do
             code = 'self.value * self.quantity'
             code.concat ' rescue 0' if options_object.rescue_error
             code
           end
 
-          subject.build
+          builder.build
         end
 
         context 'without options' do
-          subject { Sinclair.new(klass, rescue_error: true) }
+          subject(:builder) { described_class.new(klass, rescue_error: true) }
 
           let(:klass) { Class.new(Purchase) }
           let(:instance) { klass.new(2.3, 5) }
@@ -33,7 +33,7 @@ describe 'yarn' do
         end
 
         context 'with options' do
-          subject { Sinclair.new(klass) }
+          subject(:model) { described_class.new(klass) }
 
           let(:klass) { Class.new(Purchase) }
           let(:instance) { klass.new(2.3, 5) }
@@ -63,8 +63,9 @@ describe 'yarn' do
         builder.add_method(:value=) { |val| @value = val }
       end
 
-      context 'after the build' do
+      describe 'after the build' do
         before { builder.build }
+
         it 'creates the expected methods' do
           expect(instance.value).to eq(10)
         end
@@ -80,7 +81,7 @@ describe 'yarn' do
         end
       end
 
-      context 'calling the build' do
+      context 'when calling the build' do
         it do
           expect do
             builder.build
@@ -112,13 +113,10 @@ describe 'yarn' do
           expect(instance.bond_name).to eq('wick, john wick')
         end
       end
-
-      describe '#bond_style' do
-      end
     end
 
     describe '#eval_and_add_method' do
-      subject { klass.new }
+      subject(:builder) { klass.new }
 
       let(:klass) do
         Class.new do
@@ -131,18 +129,18 @@ describe 'yarn' do
       describe '#age' do
         context 'when it has not been initialized' do
           it do
-            expect(subject.age).to eq(20)
+            expect(builder.age).to eq(20)
           end
         end
 
         context 'when it has been initialized' do
           before do
-            subject.age
-            subject.age = 30
+            builder.age
+            builder.age = 30
           end
 
           it do
-            expect(subject.age).to eq(30)
+            expect(builder.age).to eq(30)
           end
         end
       end

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

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe Sinclair::Matchers::AddMethod do
-  subject { described_class.new(method) }
+  subject(:matcher) { described_class.new(method) }
 
   let(:method)   { :the_method }
   let(:klass)    { Class.new }
@@ -11,22 +11,21 @@ describe Sinclair::Matchers::AddMethod do
 
   describe '#to' do
     it do
-      expect(subject.to(klass.new)).to be_a(Sinclair::Matchers::AddMethodTo)
+      expect(matcher.to(klass.new)).to be_a(Sinclair::Matchers::AddMethodTo)
     end
 
     it 'returns an add_method_to' do
-      expect(subject.to(instance)).to eq(Sinclair::Matchers::AddMethodTo.new(instance, method))
+      expect(matcher.to(instance)).to eq(Sinclair::Matchers::AddMethodTo.new(instance, method))
     end
   end
 
   describe '#matches?' do
     it do
-      expect do
-        subject.matches?(proc {})
-      end.to raise_error(
-        SyntaxError, 'You should specify which instance the method is being added to' \
+      expect { matcher.matches?(proc {}) }
+        .to raise_error(
+          SyntaxError, 'You should specify which instance the method is being added to' \
           "add_method(:#{method}).to(instance)"
-      )
+        )
     end
   end
 end

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

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe Sinclair::Matchers::AddMethodTo do
-  subject { described_class.new(instance, method) }
+  subject(:matcher) { described_class.new(instance, method) }
 
   let(:method)   { :the_method }
   let(:klass)    { Class.new }
@@ -15,13 +15,13 @@ describe Sinclair::Matchers::AddMethodTo do
     end
 
     context 'when a method is added' do
-      it { expect(subject.matches?(event_proc)).to be_truthy }
+      it { expect(matcher).to be_matches(event_proc) }
     end
 
     context 'when a method is not added' do
       let(:event_proc) { proc {} }
 
-      it { expect(subject.matches?(event_proc)).to be_falsey }
+      it { expect(matcher).not_to be_matches(event_proc) }
     end
 
     context 'when the wrong method is added' do
@@ -29,69 +29,71 @@ describe Sinclair::Matchers::AddMethodTo do
         proc { klass.send(:define_method, :another_method) {} }
       end
 
-      it { expect(subject.matches?(event_proc)).to be_falsey }
+      it { expect(matcher).not_to be_matches(event_proc) }
     end
 
     context 'when initializing with class' do
-      subject { described_class.new(klass, method) }
+      subject(:matcher) { described_class.new(klass, method) }
 
       context 'when a method is added' do
-        it { expect(subject.matches?(event_proc)).to be_truthy }
+        it { expect(matcher).to be_matches(event_proc) }
       end
     end
   end
 
   describe '#failure_message_for_should' do
     it 'returns information on the instance class and method' do
-      expect(subject.failure_message_for_should)
+      expect(matcher.failure_message_for_should)
         .to eq("expected '#{method}' to be added to #{klass} but it didn't")
     end
 
     context 'when method already exited' do
       before do
         klass.send(:define_method, method) {}
-        subject.matches?(proc {})
+        matcher.matches?(proc {})
       end
 
       it 'returns information on the instance class and method' do
-        expect(subject.failure_message_for_should)
+        expect(matcher.failure_message_for_should)
           .to eq("expected '#{method}' to be added to #{klass} but it already existed")
       end
     end
 
     context 'when initializing with class' do
-      subject { described_class.new(klass, method) }
+      subject(:matcher) { described_class.new(klass, method) }
 
       it 'returns information on the instance class and method' do
-        expect(subject.failure_message_for_should)
+        expect(matcher.failure_message_for_should)
           .to eq("expected '#{method}' to be added to #{klass} but it didn't")
       end
+    end
 
-      context 'when method already exited' do
-        before do
-          klass.send(:define_method, method) {}
-          subject.matches?(proc {})
-        end
+    context 'when initializing with class and method already exited' do
+      subject(:matcher) { described_class.new(klass, method) }
 
-        it 'returns information on the instance class and method' do
-          expect(subject.failure_message_for_should)
-            .to eq("expected '#{method}' to be added to #{klass} but it already existed")
-        end
+      before do
+        klass.send(:define_method, method) {}
+        matcher.matches?(proc {})
+      end
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should)
+          .to eq("expected '#{method}' to be added to #{klass} but it already existed")
       end
     end
   end
 
   describe '#failure_message_for_should_not' do
     it 'returns information on the instance class and method' do
-      expect(subject.failure_message_for_should_not)
+      expect(matcher.failure_message_for_should_not)
         .to eq("expected '#{method}' not to be added to #{klass} but it was")
     end
 
     context 'when initializing with class' do
-      subject { described_class.new(klass, method) }
+      subject(:matcher) { described_class.new(klass, method) }
 
       it 'returns information on the instance class and method' do
-        expect(subject.failure_message_for_should_not)
+        expect(matcher.failure_message_for_should_not)
           .to eq("expected '#{method}' not to be added to #{klass} but it was")
       end
     end
@@ -99,15 +101,15 @@ describe Sinclair::Matchers::AddMethodTo do
 
   describe 'description' do
     it 'returns information on the instance class and method' do
-      expect(subject.description)
+      expect(matcher.description)
         .to eq("add method '#{method}' to #{klass} instances")
     end
 
     context 'when initializing with class' do
-      subject { described_class.new(klass, method) }
+      subject(:matcher) { described_class.new(klass, method) }
 
       it 'returns information on the instance class and method' do
-        expect(subject.description)
+        expect(matcher.description)
           .to eq("add method '#{method}' to #{klass} instances")
       end
     end

data/spec/lib/sinclair/method_definition_spec.rb

@@ -2,48 +2,103 @@
 
 require 'spec_helper'
 
+shared_examples 'MethodDefinition#build' do
+  it do
+    expect { method_definition.build(klass) }.to add_method(method_name).to(klass)
+  end
+
+  describe 'after build' do
+    before do
+      method_definition.build(klass)
+    end
+
+    it 'adds the method to the klass instance' do
+      expect(instance).to respond_to(method_name)
+    end
+
+    it 'evaluates return of the method within the instance context' do
+      expect(instance.the_method).to eq(1)
+    end
+
+    it 'evaluates in the context of the instance' do
+      expect { instance.the_method }
+        .to change { instance.instance_variable_get(:@x) }
+        .from(nil).to(1)
+    end
+  end
+end
+
 describe Sinclair::MethodDefinition do
-  let(:klass) { Class.new }
+  let(:klass)    { Class.new }
   let(:instance) { klass.new }
 
   describe '#build' do
     let(:method_name) { :the_method }
 
-    context 'when method was defined with an string' do
-      let(:code) { '"Self ==> " + self.to_s' }
+    context 'when method was defined with a string' do
+      subject(:method_definition) do
+        described_class.new(method_name, code)
+      end
 
-      subject { described_class.new(method_name, code) }
+      let(:code) { '@x = @x.to_i + 1' }
 
-      before do
-        subject.build(klass)
-      end
+      it_behaves_like 'MethodDefinition#build'
 
-      it 'adds the method to the klass instance' do
-        expect(instance).to respond_to(method_name)
+      it 'creates a dynamic method' do
+        method_definition.build(klass)
+        expect { instance.the_method }.to change(instance, :the_method)
+          .from(1).to(3)
       end
 
-      it 'evaluates return of the method within the instance context' do
-        expect(instance.the_method).to eq("Self ==> #{instance}")
+      context 'with cached options' do
+        subject(:method_definition) do
+          described_class.new(method_name, code, cached: true)
+        end
+
+        it_behaves_like 'MethodDefinition#build'
+
+        it 'creates a semi-dynamic method' do
+          method_definition.build(klass)
+          expect { instance.the_method }.not_to change(instance, :the_method)
+        end
       end
     end
 
     context 'when method was defined with a block' do
-      subject do
+      subject(:method_definition) do
         described_class.new(method_name) do
-          'Self ==> ' + to_s
+          @x = @x.to_i + 1
         end
       end
 
-      before do
-        subject.build(klass)
-      end
+      it_behaves_like 'MethodDefinition#build'
 
-      it 'adds the method to the klass instance' do
-        expect(instance).to respond_to(method_name)
+      it 'creates a dynamic method' do
+        method_definition.build(klass)
+        expect { instance.the_method }.to change(instance, :the_method)
+          .from(1).to(3)
       end
 
-      it 'evaluates return of the method within the instance context' do
-        expect(instance.the_method).to eq("Self ==> #{instance}")
+      context 'with cached options' do
+        subject(:method_definition) do
+          described_class.new(method_name, cached: true) do
+            @x = @x.to_i + 1
+          end
+        end
+
+        it_behaves_like 'MethodDefinition#build'
+
+        it 'creates a dynamic method' do
+          method_definition.build(klass)
+          expect { instance.the_method }.not_to change(instance, :the_method)
+        end
+
+        it 'sets the instance variable' do
+          method_definition.build(klass)
+          expect { instance.the_method }
+            .to change { instance.instance_variable_get("@#{method_name}") }
+            .from(nil).to(1)
+        end
       end
     end
   end

data/spec/lib/sinclair/options_parser_spec.rb

@@ -3,24 +3,22 @@
 require 'spec_helper'
 
 describe Sinclair::OptionsParser do
-  let(:klass) { described_class::Dummy }
-  let(:switched) { true }
-  let(:value_1) { 'value1' }
-  let(:options) { { switch: switched, option_1: value_1, option_2: 2 } }
+  subject(:model) { klass.new(options) }
 
-  subject do
-    klass.new(options)
-  end
+  let(:klass)    { described_class::Dummy }
+  let(:switched) { true }
+  let(:value_1)  { 'value1' }
+  let(:options)  { { switch: switched, option_1: value_1, option_2: 2 } }
 
   it 'enables the given options to be acced' do
-    expect(subject.the_method).to eq('The value is value1')
+    expect(model.the_method).to eq('The value is value1')
   end
 
   context 'when changing the options' do
     let(:switched) { false }
 
     it 'enables the given options to be acced' do
-      expect(subject.the_method).to eq('The value is not value1 but 2')
+      expect(model.the_method).to eq('The value is not value1 but 2')
     end
   end
 
@@ -28,33 +26,34 @@ describe Sinclair::OptionsParser do
     let(:options) { { option_1: 'value1', option_2: 2 } }
 
     it do
-      expect { subject.the_method }.not_to raise_error
+      expect { model.the_method }.not_to raise_error
     end
 
     it 'considers is to be nil' do
-      expect(subject.the_method).to eq('missing option')
+      expect(model.the_method).to eq('missing option')
     end
   end
 
   context 'when changing the options before the option call' do
     before do
-      subject
+      model
       options[:switch] = false
     end
 
     it 'does not reevaluate the options' do
-      expect(subject.the_method).to eq('The value is value1')
+      expect(model.the_method).to eq('The value is value1')
     end
 
     context 'when the option value is another object on its own' do
       let(:value_1) { { key: 'value' } }
+
       before do
-        subject
+        model
         options[:option_1][:key] = 100
       end
 
       it 'does not reevaluate the options' do
-        expect(subject.the_method).to eq('The value is {:key=>"value"}')
+        expect(model.the_method).to eq('The value is {:key=>"value"}')
       end
     end
   end