sinclair 1.6.5 → 1.7.0

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

@@ -13,5 +13,14 @@ describe Sinclair::OptionsParser do
         expect(model.the_method).to eq('The value is not 10 but 20')
       end
     end
+
+    describe '.skip_validation' do
+      it 'accepts options' do
+        options = BuilderOptions.new(name: 'Joe', age: 10)
+
+        expect(options.name).to eq('Joe')
+        expect(options.try(:age)).to be_nil
+      end
+    end
   end
 end

data/spec/lib/sinclair/config_class_spec.rb

@@ -16,38 +16,6 @@ describe Sinclair::ConfigClass do
   end
 
   describe '.add_configs' do
-    let(:setter_block) do
-      proc { |value| config.instance_variable_set(:@name, value) }
-    end
-
-    it_behaves_like 'a config methods builder adding config' do
-      let(:code_block) { proc { klass.add_configs(:name) } }
-
-      it 'sets nil value by default' do
-        code_block.call
-        expect(config.name).to be_nil
-      end
-
-      it 'adds attributes to class' do
-        expect(&code_block).to change(klass, :config_attributes)
-          .from([]).to(%i[name])
-      end
-    end
-
-    context 'when giving defaults' do
-      it_behaves_like 'a config methods builder adding config' do
-        let(:code_block) { proc { klass.add_configs(name: 'Bob') } }
-
-        it 'sets default value' do
-          code_block.call
-          expect(config.name).to eq('Bob')
-        end
-
-        it 'adds attributes to class' do
-          expect(&code_block).to change(klass, :config_attributes)
-            .from([]).to(%i[name])
-        end
-      end
-    end
+    it_behaves_like 'a config class with .add_configs method'
   end
 end

data/spec/lib/sinclair/config_spec.rb

@@ -13,6 +13,10 @@ describe Sinclair::Config do
     it_behaves_like 'a config class with .config_attributes method'
   end
 
+  describe '.add_configs' do
+    it_behaves_like 'a config class with .add_configs method'
+  end
+
   describe '#to_hash' do
     it 'returns empty hash' do
       expect(config.as_json).to eq({})
@@ -104,4 +108,71 @@ describe Sinclair::Config do
       end
     end
   end
+
+  describe '#options' do
+    let(:expected_options) do
+      klass.options_class.new(username: :user, password: nil)
+    end
+
+    before do
+      klass.add_configs(:password, username: :user)
+    end
+
+    it do
+      expect(config.options).to be_a(Sinclair::Options)
+    end
+
+    it 'returns an option with default values' do
+      expect(config.options)
+        .to eq(expected_options)
+    end
+
+    context 'when config has been changed' do
+      let(:builder) do
+        Sinclair::ConfigBuilder.new(config, :username, :password)
+      end
+
+      let(:expected_options) do
+        klass.options_class.new(
+          username: :other_user, password: :some_password
+        )
+      end
+
+      before do
+        builder.username :other_user
+        builder.password :some_password
+      end
+
+      it 'returns an option with values from config' do
+        expect(config.options)
+          .to eq(expected_options)
+      end
+    end
+
+    context 'when passing options_hash' do
+      let(:expected_options) do
+        klass.options_class.new(
+          username: :user, password: :some_password
+        )
+      end
+
+      it 'returns merged options' do
+        expect(config.options(password: :some_password))
+          .to eq(expected_options)
+      end
+    end
+
+    context 'when passing options_hash with string keys' do
+      let(:expected_options) do
+        klass.options_class.new(
+          username: :user, password: :some_password
+        )
+      end
+
+      it 'returns merged options' do
+        expect(config.options('password' => :some_password))
+          .to eq(expected_options)
+      end
+    end
+  end
 end

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

@@ -13,22 +13,46 @@ describe Sinclair::Matchers::AddClassMethodTo 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 class does not have the method yet' do
+      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 {} }
+      context 'when a method is not added' do
+        let(:event_proc) { proc {} }
 
-      it { expect(matcher).not_to be_matches(event_proc) }
-    end
+        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 the wrong method is added' do
-      let(:event_proc) do
-        proc { klass.send(:define_singleton_method, :another_method) {} }
+      context 'when method already existed' do
+        before { event_proc.call }
+
+        it { expect(matcher).not_to be_matches(event_proc) }
       end
 
-      it { expect(matcher).not_to be_matches(event_proc) }
+      context 'when method is added to instances' do
+        let(:event_proc) do
+          proc { klass.send(:define_method, method) {} }
+        end
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+    end
+
+    context 'when class already has the method' do
+      before { klass.send(:define_singleton_method, method) {} }
+
+      context 'when a method is changed' do
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
     end
 
     context 'when a block is given' do
@@ -36,7 +60,7 @@ describe Sinclair::Matchers::AddClassMethodTo 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?'
+            'Perhaps you want to use `{ ... }` instead of do/end?'
           )
       end
     end
@@ -45,7 +69,7 @@ describe Sinclair::Matchers::AddClassMethodTo do
   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")
+        .to eq("expected class method '#{method}' to be added to #{klass} but it didn't")
     end
 
     context 'when method already exited' do
@@ -56,7 +80,7 @@ describe Sinclair::Matchers::AddClassMethodTo 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 already existed")
+          .to eq("expected class method '#{method}' to be added to #{klass} but it already existed")
       end
     end
   end
@@ -64,14 +88,14 @@ describe Sinclair::Matchers::AddClassMethodTo do
   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")
+        .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}")
+        .to eq("add class method '#{method}' to #{klass}")
     end
   end
 end

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

@@ -14,22 +14,46 @@ describe Sinclair::Matchers::AddInstanceMethodTo do
       proc { klass.send(:define_method, method) {} }
     end
 
-    context 'when a method is added' do
-      it { expect(matcher).to be_matches(event_proc) }
-    end
+    context 'when class does not have the method yet' do
+      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 {} }
+      context 'when a method is not added' do
+        let(:event_proc) { proc {} }
 
-      it { expect(matcher).not_to be_matches(event_proc) }
-    end
+        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_method, :another_method) {} }
+        end
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+
+      context 'when method already existed' do
+        before { event_proc.call }
+
+        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_method, :another_method) {} }
+      context 'when method is added to the class' do
+        let(:event_proc) do
+          proc { klass.send(:define_singleton_method, method) {} }
+        end
+
+        it { expect(matcher).not_to be_matches(event_proc) }
       end
+    end
 
-      it { expect(matcher).not_to be_matches(event_proc) }
+    context 'when class already has the method' do
+      before { klass.send(:define_method, method) {} }
+
+      context 'when a method is changed' do
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
     end
 
     context 'when initializing with class' do
@@ -45,7 +69,7 @@ describe Sinclair::Matchers::AddInstanceMethodTo do
         expect { matcher.matches?(event_proc) { 1 } }
           .to raise_error(
             SyntaxError, 'Block not received by the `add_instance_method_to` matcher. ' \
-          'Perhaps you want to use `{ ... }` instead of do/end?'
+            'Perhaps you want to use `{ ... }` instead of do/end?'
           )
       end
     end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Matchers::ChangeClassMethodOn 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 class has the method' do
+      before { klass.send(:define_singleton_method, method) {} }
+
+      context 'when a method is changed' do
+        it { expect(matcher).to be_matches(event_proc) }
+      end
+
+      context 'when a method is not changed' do
+        let(:event_proc) { proc {} }
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+
+      context 'when the wrong method is changed' 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 method is changed on the class' do
+        let(:event_proc) do
+          proc { klass.send(:define_method, method) {} }
+        end
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+    end
+
+    context 'when class does not have the method' do
+      context 'when a method is added' do
+        it { expect(matcher).not_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 `change_class_method_on` matcher. ' \
+            'Perhaps you want to use `{ ... }` instead of do/end?'
+          )
+      end
+    end
+  end
+
+  describe '#failure_message_for_should' do
+    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 changed on #{klass} but it didn't")
+      end
+    end
+
+    context 'when method did not exite' 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 changed on #{klass} but it didn't exist")
+      end
+    end
+
+    context 'when initializing with class and method already existed' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      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 changed on #{klass} but it didn't")
+      end
+    end
+
+    context 'when initializing with class and method didnt exist' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should)
+          .to eq("expected class method '#{method}' to be changed on #{klass} but it didn't exist")
+      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 changed on #{klass} but it was")
+    end
+
+    context 'when initializing with class' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      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 changed on #{klass} but it was")
+      end
+    end
+  end
+
+  describe 'description' do
+    it 'returns information on the instance class and method' do
+      expect(matcher.description)
+        .to eq("change class method '#{method}' on #{klass}")
+    end
+
+    context 'when initializing with class' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.description)
+          .to eq("change class method '#{method}' on #{klass}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Matchers::ChangeClassMethod do
+  subject(:matcher) { described_class.new(method) }
+
+  let(:method)   { :the_method }
+  let(:klass)    { Class.new }
+
+  describe '#on' do
+    it do
+      expect(matcher.on(klass.new))
+        .to be_a(Sinclair::Matchers::ChangeClassMethodOn)
+    end
+
+    it 'returns an add_class_method_to' do
+      expect(matcher.on(klass))
+        .to eq(Sinclair::Matchers::ChangeClassMethodOn.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 changed on' \
+          "change_class_method(:#{method}).on(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/change_instance_method_on_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Matchers::ChangeInstanceMethodOn do
+  subject(:matcher) { described_class.new(instance, method) }
+
+  let(:method)   { :the_method }
+  let(:klass)    { Class.new }
+  let(:instance) { klass.new }
+
+  describe '#matches?' do
+    let(:event_proc) do
+      proc { klass.send(:define_method, method) {} }
+    end
+
+    context 'when class has the method' do
+      before { klass.send(:define_method, method) {} }
+
+      context 'when a method is changed' do
+        it { expect(matcher).to be_matches(event_proc) }
+      end
+
+      context 'when a method is not changed' do
+        let(:event_proc) { proc {} }
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+
+      context 'when the wrong method is changed' do
+        let(:event_proc) do
+          proc { klass.send(:define_method, :another_method) {} }
+        end
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+
+      context 'when method is changed on the class' do
+        let(:event_proc) do
+          proc { klass.send(:define_singleton_method, method) {} }
+        end
+
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+    end
+
+    context 'when class does not have the method' do
+      context 'when a method is added' do
+        it { expect(matcher).not_to be_matches(event_proc) }
+      end
+    end
+
+    context 'when initializing with class' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      before { klass.send(:define_method, method) {} }
+
+      context 'when a method is added' 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 `change_instance_method_on` matcher. ' \
+            'Perhaps you want to use `{ ... }` instead of do/end?'
+          )
+      end
+    end
+  end
+
+  describe '#failure_message_for_should' do
+    context 'when method already exited' do
+      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 changed on #{klass} but it didn't")
+      end
+    end
+
+    context 'when method did not exite' do
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should)
+          .to eq("expected '#{method}' to be changed on #{klass} but it didn't exist")
+      end
+    end
+
+    context 'when initializing with class and method already existed' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      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 changed on #{klass} but it didn't")
+      end
+    end
+
+    context 'when initializing with class and method didnt exist' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should)
+          .to eq("expected '#{method}' to be changed on #{klass} but it didn't exist")
+      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 '#{method}' not to be changed on #{klass} but it was")
+    end
+
+    context 'when initializing with class' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.failure_message_for_should_not)
+          .to eq("expected '#{method}' not to be changed on #{klass} but it was")
+      end
+    end
+  end
+
+  describe 'description' do
+    it 'returns information on the instance class and method' do
+      expect(matcher.description)
+        .to eq("change method '#{method}' on #{klass} instances")
+    end
+
+    context 'when initializing with class' do
+      subject(:matcher) { described_class.new(klass, method) }
+
+      it 'returns information on the instance class and method' do
+        expect(matcher.description)
+          .to eq("change method '#{method}' on #{klass} instances")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Matchers::ChangeInstanceMethod do
+  subject(:matcher) { described_class.new(method) }
+
+  let(:method)   { :the_method }
+  let(:klass)    { Class.new }
+  let(:instance) { klass.new }
+
+  describe '#on' do
+    it do
+      expect(matcher.on(klass.new)).to be_a(Sinclair::Matchers::ChangeInstanceMethodOn)
+    end
+
+    it 'returns an change_instance_method_on' do
+      expect(matcher.on(instance))
+        .to eq(Sinclair::Matchers::ChangeInstanceMethodOn.new(instance, method))
+    end
+  end
+
+  describe '#matches?' do
+    it do
+      expect { matcher.matches?(proc {}) }
+        .to raise_error(
+          SyntaxError, 'You should specify which instance the method is being changed on' \
+          "change_method(:#{method}).on(instance)"
+        )
+    end
+  end
+
+  describe '#supports_block_expectations?' do
+    it do
+      expect(matcher).to be_supports_block_expectations
+    end
+  end
+end