sinclair 1.8.0 → 1.10.0

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::EqualsChecker do
+  describe '#yard' do
+    describe '#match?' do
+      it 'regular usage' do
+        checker = Sinclair::EqualsChecker.new(:name, :age)
+
+        model1 = SampleModel.new(name: 'jack', age: 21)
+        model2 = SampleModel.new(name: 'rose', age: 23)
+
+        expect(checker.match?(model1, model2)).to be_falsey
+      end
+
+      it 'similar models' do
+        checker = Sinclair::EqualsChecker.new(:name, :age)
+
+        model1 = SampleModel.new(name: 'jack', age: 21)
+        model2 = SampleModel.new(name: 'jack', age: 21)
+
+        expect(checker.match?(model1, model2)).to be_truthy
+      end
+
+      it 'different classes' do
+        checker = Sinclair::EqualsChecker.new(:name, :age)
+
+        model1 = SampleModel.new(name: 'jack', age: 21)
+        model2 = OtherModel.new(name: 'jack', age: 21)
+
+        expect(checker.match?(model1, model2)).to be_falsey
+      end
+    end
+
+    describe '#add' do
+      it 'adding fields to equal checker' do
+        checker = Sinclair::EqualsChecker.new(:name)
+
+        model1 = SampleModel.new(name: 'jack', age: 21)
+        model2 = SampleModel.new(name: 'jack', age: 22)
+
+        expect(checker.match?(model1, model2)).to be_truthy
+
+        checker.add(:age)
+
+        expect(checker.match?(model1, model2)).to be_falsey
+      end
+    end
+  end
+end

data/spec/integration/yard/sinclair/matchers/change_class_method_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Sinclair::Matchers::ChangeClassMethod do
+  describe 'yard' do
+    describe '#on' do
+      context 'when checking against Class' do
+        let(:klass)   { Class.new(MyModel) }
+        let(:builder) { Sinclair.new(klass) }
+
+        before do
+          builder.add_class_method(:the_method) { 10 }
+          builder.build
+          builder.add_class_method(:the_method) { 20 }
+        end
+
+        it do
+          expect { builder.build }.to change_class_method(:the_method).on(klass)
+        end
+      end
+    end
+  end
+end

data/spec/integration/yard/sinclair/matchers/change_instance_method_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Sinclair::Matchers::ChangeInstanceMethod do
+  describe 'yard' do
+    describe '#on' do
+      context 'when checking against Class' do
+        let(:klass)   { Class.new(MyModel) }
+        let(:builder) { Sinclair.new(klass) }
+
+        before do
+          builder.add_method(:the_method) { 10 }
+          builder.build
+          builder.add_method(:the_method) { 20 }
+        end
+
+        it do
+          expect { builder.build }.to change_method(:the_method).on(klass)
+        end
+      end
+
+      context 'when checking against an intance' do
+        let(:klass)    { Class.new(MyModel) }
+        let(:instance) { klass.new }
+        let(:builder)  { Sinclair.new(klass) }
+
+        before do
+          builder.add_method(:the_method) { 10 }
+          builder.build
+          builder.add_method(:the_method) { 20 }
+        end
+
+        it do
+          expect { builder.build }.to change_method(:the_method).on(instance)
+        end
+      end
+    end
+  end
+end

data/spec/lib/sinclair/comparable_spec.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Comparable do
+  let(:model_class) do
+    Class.new(SampleModel) do
+      include Sinclair::Comparable
+    end
+  end
+
+  let(:attributes)   { %i[] }
+  let(:model1_class) { model_class }
+  let(:model2_class) { model_class }
+  let(:model1)       { model1_class.new(**model1_attributes) }
+  let(:model2)       { model2_class.new(**model2_attributes) }
+
+  let(:model1_attributes) { { name: name1, age: age1 } }
+  let(:model2_attributes) { { name: name2, age: age2 } }
+  let(:name1)             { SecureRandom.hex(10) }
+  let(:name2)             { SecureRandom.hex(10) }
+  let(:age1)              { Random.rand(10..20) }
+  let(:age2)              { Random.rand(21..50) }
+
+  describe '.comparable_by' do
+    let(:model2_class) { model1_class }
+
+    context 'when no field was present' do
+      it 'adds the field for comparison' do
+        expect { model1_class.comparable_by(:name) }
+          .to change { model1 == model2 }
+          .from(true).to(false)
+      end
+    end
+
+    context 'when there was a field present' do
+      let(:name2) { name1 }
+
+      before { model1_class.comparable_by(:name) }
+
+      it 'adds the field for comparison' do
+        expect { model1_class.comparable_by(:age) }
+          .to change { model1 == model2 }
+          .from(true).to(false)
+      end
+    end
+
+    context 'when there was a field present and it made a non match' do
+      let(:age2) { age1 }
+
+      before { model1_class.comparable_by(:name) }
+
+      it 'adds the field for comparison without forgeting the previous' do
+        expect { model1_class.comparable_by(:age) }
+          .not_to change { model1 == model2 }
+          .from(false)
+      end
+    end
+
+    context 'when the class parent class adds a field' do
+      let(:model1_class) { Class.new(model_class) }
+      let(:model2_class) { model1_class }
+
+      it 'takes the field into consideration' do
+        expect { model_class.comparable_by(:name) }
+          .to change { model1 == model2 }
+          .from(true).to(false)
+      end
+
+      context 'when we add a field to the class itself' do
+        let(:name2) { name1 }
+
+        before { model_class.comparable_by(:name) }
+
+        it 'takes all fields into consideration' do
+          expect { model1_class.comparable_by(:age) }
+            .to change { model1 == model2 }
+            .from(true).to(false)
+        end
+      end
+
+      context 'when we add a field to the parent class after' do
+        let(:name2) { name1 }
+
+        before { model1_class.comparable_by(:name) }
+
+        it 'takes all fields into consideration' do
+          expect { model_class.comparable_by(:age) }
+            .to change { model1 == model2 }
+            .from(true).to(false)
+        end
+      end
+    end
+  end
+
+  describe '#==' do
+    before do
+      model1_class.comparable_by(attributes)
+      model2_class.comparable_by(attributes)
+    end
+
+    context 'when the attributes is empty' do
+      context 'when they are different classes and attributes are the same' do
+        let(:model2_class) { Class.new(model1_class) }
+        let(:name2)        { name1 }
+        let(:age2)         { age1 }
+
+        it do
+          expect(model1).not_to eq(model2)
+        end
+      end
+
+      context 'when the models have the same attributes' do
+        let(:name2) { name1 }
+        let(:age2)  { age1 }
+
+        it do
+          expect(model1).to eq(model2)
+        end
+      end
+
+      context 'when the models have very different attributes' do
+        it do
+          expect(model1).to eq(model2)
+        end
+      end
+    end
+
+    context 'when the attributes is missing just one attribute' do
+      let(:attributes) { %i[name] }
+
+      context 'when they are different classes and attributes are the same' do
+        let(:model2_class) { Class.new(model1_class) }
+        let(:name2)        { name1 }
+        let(:age2)         { age1 }
+
+        it do
+          expect(model1).not_to eq(model2)
+        end
+      end
+
+      context 'when the models have a non listed different attribute' do
+        let(:name2) { name1 }
+
+        it do
+          expect(model1).to eq(model2)
+        end
+      end
+
+      context 'when the models have a listed different attribute' do
+        let(:age2) { age1 }
+
+        it do
+          expect(model1).not_to eq(model2)
+        end
+      end
+
+      context 'when the models have very different attributes' do
+        it do
+          expect(model1).not_to eq(model2)
+        end
+      end
+    end
+
+    context 'when all attributes are included' do
+      let(:attributes) { %i[name age] }
+
+      context 'when they are different classes and attributes are the same' do
+        let(:model2_class) { Class.new(model1_class) }
+        let(:name2)        { name1 }
+        let(:age2)         { age1 }
+
+        it do
+          expect(model1).not_to eq(model2)
+        end
+      end
+
+      context 'when the models have the same attributes' do
+        let(:name2) { name1 }
+        let(:age2)  { age1 }
+
+        it do
+          expect(model1).to eq(model2)
+        end
+      end
+
+      context 'when the models have a listed different attribute' do
+        let(:name) { name1 }
+
+        it do
+          expect(model1).not_to eq(model2)
+        end
+      end
+
+      context 'when the models have very different attributes' do
+        it do
+          expect(model1).not_to eq(model2)
+        end
+      end
+    end
+  end
+end

data/spec/lib/sinclair/equals_checker_spec.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::EqualsChecker do
+  subject(:checker) { described_class.new(attributes) }
+
+  let(:attributes) { %i[] }
+
+  let(:model1_class) { SampleModel }
+  let(:model2_class) { SampleModel }
+  let(:model1)       { model1_class.new(**model1_attributes) }
+  let(:model2)       { model2_class.new(**model2_attributes) }
+
+  let(:model1_attributes) { { name: name1, age: age1 } }
+  let(:model2_attributes) { { name: name2, age: age2 } }
+  let(:name1)             { SecureRandom.hex(10) }
+  let(:name2)             { SecureRandom.hex(10) }
+  let(:age1)              { Random.rand(10..20) }
+  let(:age2)              { Random.rand(21..50) }
+
+  describe 'match?' do
+    context 'when the attributes is empty' do
+      context 'when they are different classes and attributes are the same' do
+        let(:model2_class) { Class.new(SampleModel) }
+        let(:name2)        { name1 }
+        let(:age2)         { age1 }
+
+        it do
+          expect(checker).not_to be_match(model1, model2)
+        end
+      end
+
+      context 'when the models have the same attributes' do
+        let(:name2) { name1 }
+        let(:age2)  { age1 }
+
+        it do
+          expect(checker).to be_match(model1, model2)
+        end
+      end
+
+      context 'when the models have very different attributes' do
+        it do
+          expect(checker).to be_match(model1, model2)
+        end
+      end
+    end
+
+    context 'when the attributes is missing just one attribute' do
+      let(:attributes) { %i[name] }
+
+      context 'when they are different classes and attributes are the same' do
+        let(:model2_class) { Class.new(SampleModel) }
+        let(:name2)        { name1 }
+        let(:age2)         { age1 }
+
+        it do
+          expect(checker).not_to be_match(model1, model2)
+        end
+      end
+
+      context 'when the models have a non listed different attribute' do
+        let(:name2) { name1 }
+
+        it do
+          expect(checker).to be_match(model1, model2)
+        end
+      end
+
+      context 'when the models have a listed different attribute' do
+        let(:age2) { age1 }
+
+        it do
+          expect(checker).not_to be_match(model1, model2)
+        end
+      end
+
+      context 'when the models have very different attributes' do
+        it do
+          expect(checker).not_to be_match(model1, model2)
+        end
+      end
+    end
+
+    context 'when all attributes are included' do
+      let(:attributes) { %i[name age] }
+
+      context 'when they are different classes and attributes are the same' do
+        let(:model2_class) { Class.new(SampleModel) }
+        let(:name2)        { name1 }
+        let(:age2)         { age1 }
+
+        it do
+          expect(checker).not_to be_match(model1, model2)
+        end
+      end
+
+      context 'when the models have the same attributes' do
+        let(:name2) { name1 }
+        let(:age2)  { age1 }
+
+        it do
+          expect(checker).to be_match(model1, model2)
+        end
+      end
+
+      context 'when the models have a listed different attribute' do
+        let(:name) { name1 }
+
+        it do
+          expect(checker).not_to be_match(model1, model2)
+        end
+      end
+
+      context 'when the models have very different attributes' do
+        it do
+          expect(checker).not_to be_match(model1, model2)
+        end
+      end
+    end
+  end
+
+  describe '#add' do
+    let(:attributes)     { [:name] }
+    let(:new_attributes) { [:age] }
+
+    context 'when the new field has different values' do
+      let(:name2) { name1 }
+
+      it 'uses the new field to the match' do
+        expect { checker.add(new_attributes) }
+          .to change { checker.match?(model1, model2) }
+          .from(true).to(false)
+      end
+    end
+
+    context 'when the old field has different values' do
+      let(:age2) { age1 }
+
+      it 'uses the new field to the match' do
+        expect { checker.add(new_attributes) }
+          .not_to change { checker.match?(model1, model2) }
+          .from(false)
+      end
+    end
+  end
+end

data/spec/lib/sinclair/method_builder/call_method_builder_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::MethodBuilder::CallMethodBuilder do
+  describe '#build' do
+    subject(:builder) do
+      described_class.new(klass, definition, type: type)
+    end
+
+    let(:call_name) { "attr_#{accessor_type}" }
+
+    let(:definition) do
+      Sinclair::MethodDefinition::CallDefinition.new(call_name, *attributes)
+    end
+
+    context 'when method called is attr_accessor' do
+      let(:accessor_type) { :accessor }
+
+      it_behaves_like 'a method builder that adds attribute reader'
+      it_behaves_like 'a method builder that adds attribute writer'
+    end
+
+    context 'when method called is attr_reader' do
+      let(:accessor_type) { :reader }
+
+      it_behaves_like 'a method builder that adds attribute reader' do
+        context 'when type is instance' do
+          let(:type) { Sinclair::MethodBuilder::INSTANCE_METHOD }
+
+          it 'does not add a reader' do
+            expect { builder.build }
+              .not_to add_method("#{method_name}=")
+              .to(instance)
+          end
+        end
+
+        context 'when type is class' do
+          let(:type) { Sinclair::MethodBuilder::CLASS_METHOD }
+
+          it 'does not add a reader' do
+            expect { builder.build }
+              .not_to add_class_method("#{method_name}=")
+              .to(klass)
+          end
+        end
+      end
+    end
+
+    context 'when method called is attr_writter' do
+      let(:accessor_type) { :writer }
+
+      it_behaves_like 'a method builder that adds attribute writer' do
+        context 'when type is instance' do
+          let(:type) { Sinclair::MethodBuilder::INSTANCE_METHOD }
+
+          it 'does not add a reader' do
+            expect { builder.build }
+              .not_to add_method(method_name)
+              .to(instance)
+          end
+        end
+
+        context 'when type is class' do
+          let(:type) { Sinclair::MethodBuilder::CLASS_METHOD }
+
+          it 'does not add a reader' do
+            expect { builder.build }
+              .not_to add_class_method(method_name)
+              .to(klass)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/sinclair/method_builder_spec.rb

@@ -11,41 +11,84 @@ describe Sinclair::MethodBuilder do
   let(:method_name) { :the_method }
   let(:instance)    { klass.new }
 
-  before do
-    definitions.add(method_name, value.to_s)
-  end
-
   describe '#build_methods' do
-    context 'when building an instance method' do
-      let(:type) { described_class::INSTANCE_METHOD }
+    context 'when the method is a string definition' do
+      before do
+        definitions.add(method_name, value.to_s)
+      end
 
-      it do
-        expect { builder.build_methods(definitions, type) }
-          .to add_method(method_name).to(instance)
+      context 'when building an instance method' do
+        let(:type) { described_class::INSTANCE_METHOD }
+
+        it do
+          expect { builder.build_methods(definitions, type) }
+            .to add_method(method_name).to(instance)
+        end
+
+        context 'when the method is called' do
+          before { builder.build_methods(definitions, type) }
+
+          it do
+            expect(instance.the_method).to eq(value)
+          end
+        end
       end
 
-      context 'when the method is called' do
-        before { builder.build_methods(definitions, type) }
+      context 'when building a class method' do
+        let(:type) { described_class::CLASS_METHOD }
 
         it do
-          expect(instance.the_method).to eq(value)
+          expect { builder.build_methods(definitions, type) }
+            .to add_class_method(method_name).to(klass)
+        end
+
+        context 'when the method is called' do
+          before { builder.build_methods(definitions, type) }
+
+          it do
+            expect(klass.the_method).to eq(value)
+          end
         end
       end
     end
 
-    context 'when building a class method' do
-      let(:type) { described_class::CLASS_METHOD }
+    context 'when the method is a block definition' do
+      before do
+        result = value
+        definitions.add(method_name) { result }
+      end
+
+      context 'when building an instance method' do
+        let(:type) { described_class::INSTANCE_METHOD }
+
+        it do
+          expect { builder.build_methods(definitions, type) }
+            .to add_method(method_name).to(instance)
+        end
 
-      it do
-        expect { builder.build_methods(definitions, type) }
-          .to add_class_method(method_name).to(klass)
+        context 'when the method is called' do
+          before { builder.build_methods(definitions, type) }
+
+          it do
+            expect(instance.the_method).to eq(value)
+          end
+        end
       end
 
-      context 'when the method is called' do
-        before { builder.build_methods(definitions, type) }
+      context 'when building a class method' do
+        let(:type) { described_class::CLASS_METHOD }
 
         it do
-          expect(klass.the_method).to eq(value)
+          expect { builder.build_methods(definitions, type) }
+            .to add_class_method(method_name).to(klass)
+        end
+
+        context 'when the method is called' do
+          before { builder.build_methods(definitions, type) }
+
+          it do
+            expect(klass.the_method).to eq(value)
+          end
         end
       end
     end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::MethodDefinition::CallDefinition do
+  subject(:definition) do
+    described_class.new(call_name, *attributes)
+  end
+
+  let(:call_name)  { :method_call }
+  let(:attributes) { %i[key1 value2] }
+
+  describe '#code_string' do
+    let(:expected) { 'method_call :key1, :value2' }
+
+    it 'returns the code string' do
+      expect(definition.code_string)
+        .to eq(expected)
+    end
+  end
+
+  describe '#class_code_string' do
+    let(:expected) do
+      <<-RUBY
+      class << self
+        method_call :key1, :value2
+      end
+      RUBY
+    end
+
+    it 'returns the code string' do
+      expect(definition.class_code_string.gsub(/^ */, ''))
+        .to eq(expected.gsub(/^ */, ''))
+    end
+  end
+end