sinclair 1.4.1 → 1.4.2

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::MethodDefinition::InstanceMethodDefinition do
+  describe 'yard' do
+    describe '#from' do
+      describe 'using string method with no options' do
+        subject(:method_definition) do
+          described_class.from(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 eq(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
+end

data/spec/integration/yard/sinclair/method_definition/{string_definition_spec.rb → instance_string_definition_spec.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe Sinclair::MethodDefinition::StringDefinition do
+describe Sinclair::MethodDefinition::InstanceStringDefinition do
   describe 'yard' do
     describe '#build' do
       subject(:method_definition) do

data/spec/integration/yard/sinclair_spec.rb

@@ -131,16 +131,43 @@ describe Sinclair do
       end
 
       describe '#full_name' do
-        let(:klass) { Class.new(Person) }
-        let(:instance) { klass.new('john', 'wick') }
+        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_method(:full_name, '[first_name, last_name].join(" ")')
+          builder.add_class_method(:hostname, 'ENV["HOSTNAME"]')
           builder.build
+          ENV['HOSTNAME'] = 'myhost'
         end
 
-        it 'returns the full name' do
-          expect(instance.bond_name).to eq('wick, john wick')
+        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

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Matchers::AddClassMethod do
+  subject(:matcher) { described_class.new(method) }
+
+  let(:method)   { :the_method }
+  let(:klass)    { Class.new }
+
+  describe '#to' do
+    it do
+      expect(matcher.to(klass.new)).to be_a(Sinclair::Matchers::AddClassMethodTo)
+    end
+
+    it 'returns an add_class_method_to' do
+      expect(matcher.to(klass)).to eq(Sinclair::Matchers::AddClassMethodTo.new(klass, method))
+    end
+  end
+
+  describe '#matches?' do
+    it do
+      expect { matcher.matches?(proc {}) }
+        .to raise_error(
+          SyntaxError, 'You should specify which class the method is being added to' \
+          "add_class_method(:#{method}).to(klass)"
+        )
+    end
+  end
+
+  describe '#supports_block_expectations?' do
+    it do
+      expect(matcher).to be_supports_block_expectations
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Matchers::AddClassMethodTo do
+  subject(:matcher) { described_class.new(klass, method) }
+
+  let(:method)   { :the_method }
+  let(:klass)    { Class.new }
+
+  describe '#matches?' do
+    let(:event_proc) do
+      proc { klass.send(:define_singleton_method, method) {} }
+    end
+
+    context 'when a method is added' do
+      it { expect(matcher).to be_matches(event_proc) }
+    end
+
+    context 'when a method is not added' do
+      let(:event_proc) { proc {} }
+
+      it { expect(matcher).not_to be_matches(event_proc) }
+    end
+
+    context 'when the wrong method is added' do
+      let(:event_proc) do
+        proc { klass.send(:define_singleton_method, :another_method) {} }
+      end
+
+      it { expect(matcher).not_to be_matches(event_proc) }
+    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_class_method_to` matcher. ' \
+          'Perhaps you want to use `{ ... }` instead of do/end?'
+          )
+      end
+    end
+  end
+
+  describe '#failure_message_for_should' do
+    it 'returns information on the instance class and method' do
+      expect(matcher.failure_message_for_should)
+        .to eq("expected class_method '#{method}' to be added to #{klass} but it didn't")
+    end
+
+    context 'when method already exited' do
+      before do
+        klass.send(:define_singleton_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 class_method '#{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(matcher.failure_message_for_should_not)
+        .to eq("expected class_method '#{method}' not to be added to #{klass} but it was")
+    end
+  end
+
+  describe 'description' do
+    it 'returns information on the instance class and method' do
+      expect(matcher.description)
+        .to eq("add method class_method '#{method}' to #{klass}")
+    end
+  end
+end

data/spec/lib/sinclair/matchers/{add_method_spec.rb → add_instance_method_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Sinclair::Matchers::AddMethod do
+describe Sinclair::Matchers::AddInstanceMethod do
   subject(:matcher) { described_class.new(method) }
 
   let(:method)   { :the_method }
@@ -11,11 +11,12 @@ describe Sinclair::Matchers::AddMethod do
 
   describe '#to' do
     it do
-      expect(matcher.to(klass.new)).to be_a(Sinclair::Matchers::AddMethodTo)
+      expect(matcher.to(klass.new)).to be_a(Sinclair::Matchers::AddInstanceMethodTo)
     end
 
-    it 'returns an add_method_to' do
-      expect(matcher.to(instance)).to eq(Sinclair::Matchers::AddMethodTo.new(instance, method))
+    it 'returns an add_instance_method_to' do
+      expect(matcher.to(instance))
+        .to eq(Sinclair::Matchers::AddInstanceMethodTo.new(instance, method))
     end
   end
 
@@ -28,4 +29,10 @@ describe Sinclair::Matchers::AddMethod do
         )
     end
   end
+
+  describe '#supports_block_expectations?' do
+    it do
+      expect(matcher).to be_supports_block_expectations
+    end
+  end
 end

data/spec/lib/sinclair/matchers/{add_method_to_spec.rb → add_instance_method_to_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Sinclair::Matchers::AddMethodTo do
+describe Sinclair::Matchers::AddInstanceMethodTo do
   subject(:matcher) { described_class.new(instance, method) }
 
   let(:method)   { :the_method }
@@ -44,7 +44,7 @@ describe Sinclair::Matchers::AddMethodTo do
       it do
         expect { matcher.matches?(event_proc) { 1 } }
           .to raise_error(
-            SyntaxError, 'Block not received by the `add_method_to` matcher. ' \
+            SyntaxError, 'Block not received by the `add_instance_method_to` matcher. ' \
           'Perhaps you want to use `{ ... }` instead of do/end?'
           )
       end

data/spec/lib/sinclair/matchers_spec.rb

@@ -9,11 +9,26 @@ describe Sinclair::Matchers do
     end
 
     it do
-      expect(add_method(:method_name)).to be_a(described_class::AddMethod)
+      expect(add_method(:method_name)).to be_a(described_class::AddInstanceMethod)
     end
 
     it 'returns the matcher with correct argument' do
-      expect(add_method(:method_name)).to eq(described_class::AddMethod.new(:method_name))
+      expect(add_method(:method_name)).to eq(described_class::AddInstanceMethod.new(:method_name))
+    end
+  end
+
+  describe '#add_class_method' do
+    it 'has been added to DSL' do
+      expect(respond_to?(:add_class_method)).to be_truthy
+    end
+
+    it do
+      expect(add_class_method(:method_name)).to be_a(described_class::AddClassMethod)
+    end
+
+    it 'returns the matcher with correct argument' do
+      expect(add_class_method(:method_name))
+        .to eq(described_class::AddClassMethod.new(:method_name))
     end
   end
 end

data/spec/lib/sinclair/method_definition/class_block_definition_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::MethodDefinition::ClassBlockDefinition do
+  let(:klass) { Class.new }
+
+  describe '#build' do
+    subject(:method_definition) do
+      described_class.new(method_name) do
+        @x = @x.to_i + 1
+      end
+    end
+
+    let(:method_name) { :the_method }
+
+    it_behaves_like 'ClassMethodDefinition#build without cache'
+
+    context 'with cached options' do
+      subject(:method_definition) do
+        described_class.new(method_name, cached: cached_option) do
+          @x = @x.to_i + 1
+        end
+      end
+
+      it_behaves_like 'ClassMethodDefinition#build with cache options'
+    end
+  end
+end

data/spec/lib/sinclair/method_definition/class_string_definition_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::MethodDefinition::ClassStringDefinition do
+  let(:klass) { Class.new }
+
+  describe '#build' do
+    subject(:method_definition) do
+      described_class.new(method_name, code)
+    end
+
+    let(:method_name) { :the_method }
+
+    let(:code) { '@x = @x.to_i + 1' }
+
+    it_behaves_like 'ClassMethodDefinition#build without cache'
+
+    context 'with cached options' do
+      subject(:method_definition) do
+        described_class.new(method_name, code, cached: cached_option)
+      end
+
+      it_behaves_like 'ClassMethodDefinition#build with cache options'
+    end
+  end
+end

data/spec/lib/sinclair/method_definition/{block_definition_spec.rb → instance_block_definition_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Sinclair::MethodDefinition::BlockDefinition do
+describe Sinclair::MethodDefinition::InstanceBlockDefinition do
   let(:klass)    { Class.new }
   let(:instance) { klass.new }
 
@@ -19,7 +19,7 @@ describe Sinclair::MethodDefinition::BlockDefinition do
 
     context 'with cached options' do
       subject(:method_definition) do
-        described_class.from(method_name, cached: cached_option) do
+        described_class.new(method_name, cached: cached_option) do
           @x = @x.to_i + 1
         end
       end

data/spec/lib/sinclair/method_definition/{string_definition_spec.rb → instance_string_definition_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Sinclair::MethodDefinition::StringDefinition do
+describe Sinclair::MethodDefinition::InstanceStringDefinition do
   let(:klass)    { Class.new }
   let(:instance) { klass.new }
 
@@ -19,7 +19,7 @@ describe Sinclair::MethodDefinition::StringDefinition do
 
     context 'with cached options' do
       subject(:method_definition) do
-        described_class.from(method_name, code, cached: cached_option)
+        described_class.new(method_name, code, cached: cached_option)
       end
 
       it_behaves_like 'MethodDefinition#build with cache options'

data/spec/lib/sinclair/method_definition_spec.rb

@@ -23,36 +23,40 @@ describe Sinclair::MethodDefinition do
       end
     end
 
-    context 'when method was defined with a string' do
+    context 'when method was defined with a string for instance' do
       subject(:method_definition) do
-        described_class.from(method_name, code)
+        definition_class.new(method_name, code)
       end
 
+      let(:definition_class) { described_class::InstanceStringDefinition }
+
       let(:code) { '@x = @x.to_i + 1' }
 
       it_behaves_like 'MethodDefinition#build without cache'
 
       context 'with cached options' do
         subject(:method_definition) do
-          described_class.from(method_name, code, cached: cached_option)
+          definition_class.new(method_name, code, cached: cached_option)
         end
 
         it_behaves_like 'MethodDefinition#build with cache options'
       end
     end
 
-    context 'when method was defined with a block' do
+    context 'when method was defined with a block for instance' do
       subject(:method_definition) do
-        described_class.from(method_name) do
+        definition_class.new(method_name) do
           @x = @x.to_i + 1
         end
       end
 
+      let(:definition_class) { described_class::InstanceBlockDefinition }
+
       it_behaves_like 'MethodDefinition#build without cache'
 
       context 'with cached options' do
         subject(:method_definition) do
-          described_class.from(method_name, cached: cached_option) do
+          definition_class.new(method_name, cached: cached_option) do
             @x = @x.to_i + 1
           end
         end
@@ -60,5 +64,47 @@ describe Sinclair::MethodDefinition do
         it_behaves_like 'MethodDefinition#build with cache options'
       end
     end
+
+    context 'when method was defined with a string for class' do
+      subject(:method_definition) do
+        definition_class.new(method_name, code)
+      end
+
+      let(:definition_class) { described_class::ClassStringDefinition }
+
+      let(:code) { '@x = @x.to_i + 1' }
+
+      it_behaves_like 'ClassMethodDefinition#build without cache'
+
+      context 'with cached options' do
+        subject(:method_definition) do
+          definition_class.new(method_name, code, cached: cached_option)
+        end
+
+        it_behaves_like 'ClassMethodDefinition#build with cache options'
+      end
+    end
+
+    context 'when method was defined with a block for class' do
+      subject(:method_definition) do
+        definition_class.new(method_name) do
+          @x = @x.to_i + 1
+        end
+      end
+
+      let(:definition_class) { described_class::ClassBlockDefinition }
+
+      it_behaves_like 'ClassMethodDefinition#build without cache'
+
+      context 'with cached options' do
+        subject(:method_definition) do
+          definition_class.new(method_name, cached: cached_option) do
+            @x = @x.to_i + 1
+          end
+        end
+
+        it_behaves_like 'ClassMethodDefinition#build with cache options'
+      end
+    end
   end
 end