sinclair 1.9.0 → 1.11.0

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: false
+
+require 'spec_helper'
+
+describe 'yard Sinclair#add_method' do
+  describe 'Using string code to add a string defined method' do
+    let(:klass) { Class.new(Person) }
+
+    it 'creates new method' do
+      builder = Sinclair.new(klass)
+      builder.add_method(:full_name, '[first_name, last_name].join(" ")')
+      builder.build
+
+      expect(klass.new('john', 'wick').full_name).to eq('john wick')
+    end
+  end
+
+  describe 'Using block to add a block method' do
+    let(:klass) { Class.new(Person) }
+
+    it 'creates new method' do
+      builder = Sinclair.new(klass)
+      builder.add_method(:bond_name) { "#{last_name}, #{first_name} #{last_name}" }
+      builder.build
+
+      expect(klass.new('john', 'wick').bond_name).to eq('wick, john wick')
+    end
+  end
+
+  describe 'Passing type block' do
+    let(:klass) { Class.new(Person) }
+
+    it 'creates new method' do
+      builder = Sinclair.new(klass)
+      builder.add_method(:bond_name, type: :block, cached: true) do
+        "#{last_name}, #{first_name} #{last_name}"
+      end
+      builder.build
+      person = klass.new('john', 'wick')
+
+      expect(person.bond_name).to eq('wick, john wick')
+      person.first_name = 'Johny'
+      expect(person.bond_name).to eq('wick, john wick')
+    end
+  end
+
+  describe 'Passing type call' do
+    let(:klass) { Class.new }
+
+    it 'creates new method' do
+      builder = Sinclair.new(klass)
+      builder.add_method(:attr_accessor, :bond_name, type: :call)
+      builder.build
+      person = klass.new
+
+      person.bond_name = 'Bond, James Bond'
+      expect(person.bond_name).to eq('Bond, James Bond')
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: false
+
+require 'spec_helper'
+
+describe 'yard Sinclair#eval_and_add_method' do
+  describe 'Building a initial value class method' do
+    let(:klass) do
+      Class.new do
+        include InitialValuer
+        attr_writer :age
+
+        initial_value_for :age, 20
+      end
+    end
+
+    context 'when it has not been initialized' do
+      it do
+        object = klass.new
+
+        expect(object.age).to eq(20)
+        object.age = 30
+        expect(object.age).to eq(30)
+      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/integration/yard/sinclair_spec.rb

@@ -119,88 +119,5 @@ describe Sinclair do
         end
       end
     end
-
-    describe '#add_method' do
-      let(:klass) { Class.new(Person) }
-      let(:instance) { klass.new('john', 'wick') }
-
-      before do
-        builder.add_method(:full_name, '[first_name, last_name].join(" ")')
-        builder.add_method(:bond_name) { "#{last_name}, #{first_name} #{last_name}" }
-        builder.build
-      end
-
-      describe '#full_name' do
-        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_class_method(:hostname, 'ENV["HOSTNAME"]')
-          builder.build
-          ENV['HOSTNAME'] = 'myhost'
-        end
-
-        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
-
-    describe '#eval_and_add_method' do
-      subject(:builder) { klass.new }
-
-      let(:klass) do
-        Class.new do
-          include InitialValuer
-          attr_writer :age
-          initial_value_for :age, 20
-        end
-      end
-
-      describe '#age' do
-        context 'when it has not been initialized' do
-          it do
-            expect(builder.age).to eq(20)
-          end
-        end
-
-        context 'when it has been initialized' do
-          before do
-            builder.age
-            builder.age = 30
-          end
-
-          it do
-            expect(builder.age).to eq(30)
-          end
-        end
-      end
-    end
   end
 end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::MethodBuilder::Base do
+  describe '.build' do
+    let(:klass) { Class.new }
+    let(:type)  { Sinclair::MethodBuilder::CLASS_METHOD }
+
+    it do
+      expect { described_class.build(klass, instance_of(described_class), type: type) }
+        .to raise_error(NotImplementedError)
+    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,33 @@
+# 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_block' do
+    let(:instance) { klass.new }
+    let(:klass) do
+      Class.new do
+        def method_call(*args)
+          args
+        end
+      end
+    end
+
+    it do
+      expect(definition.code_block)
+        .to be_a(Proc)
+    end
+
+    it 'returns a proc with the method call' do
+      expect(instance.instance_eval(&definition.code_block))
+        .to eq(attributes)
+    end
+  end
+end

data/spec/lib/sinclair/method_definition_spec.rb

@@ -5,6 +5,48 @@ require 'spec_helper'
 describe Sinclair::MethodDefinition do
   let(:method_name) { :the_method }
 
+  describe '.build' do
+    subject(:definition) do
+      definition_class.new(method_name, **options)
+    end
+
+    let(:definition_class) { Class.new(described_class) }
+    let(:options)          { {} }
+    let(:klass)            { Class.new }
+    let(:type)             { Sinclair::MethodBuilder::CLASS_METHOD }
+
+    context 'when the builder has not been defined' do
+      it do
+        expect { definition.build(klass, type) }
+          .to raise_error(NotImplementedError)
+      end
+    end
+
+    context 'when the builder has been defined' do
+      let(:definition_class) do
+        Class.new(described_class) do
+          def code_line
+            '10'
+          end
+        end
+      end
+
+      before do
+        definition_class.build_with(Sinclair::MethodBuilder::StringMethodBuilder)
+      end
+
+      it do
+        expect { definition.build(klass, type) }
+          .not_to raise_error
+      end
+
+      it 'builds the method using the builder' do
+        expect { definition.build(klass, type) }
+          .to add_class_method(method_name).to(klass)
+      end
+    end
+  end
+
   describe '.default_value' do
     subject(:klass) { Class.new(described_class) }
 
@@ -42,4 +84,91 @@ describe Sinclair::MethodDefinition do
       end
     end
   end
+
+  describe '.for' do
+    let(:klass) { Class.new }
+
+    context 'when there are no options nor block' do
+      let(:type)      { :call }
+      let(:arguments) { %i[attr_reader some_attribute other_attribute] }
+
+      it do
+        expect(described_class.for(type, *arguments))
+          .to be_a(described_class)
+      end
+
+      it 'Returns an instance of the given type' do
+        expect(described_class.for(type, *arguments))
+          .to be_a(described_class::CallDefinition)
+      end
+
+      it 'initializes it correctly' do
+        expect { klass.module_eval(&described_class.for(type, *arguments).code_block) }
+          .to add_method(:some_attribute).to(klass)
+      end
+    end
+
+    context 'when type is not given' do
+      let(:type)        { nil }
+      let(:method_name) { :the_method }
+      let(:block)       { proc { 10 } }
+
+      it do
+        expect(described_class.for(type, method_name, &block))
+          .to be_a(described_class)
+      end
+
+      it 'infers the definition from arguments' do
+        expect(described_class.for(type, method_name, &block))
+          .to be_a(described_class::BlockDefinition)
+      end
+
+      it 'initializes it correctly' do
+        expect(described_class.for(type, method_name, &block).name)
+          .to eq(method_name)
+      end
+    end
+
+    context 'when a block is given' do
+      let(:type)        { :block }
+      let(:method_name) { :the_method }
+      let(:block)       { proc { 10 } }
+
+      it do
+        expect(described_class.for(type, method_name, &block))
+          .to be_a(described_class)
+      end
+
+      it 'Returns an instance of the given type' do
+        expect(described_class.for(type, method_name, &block))
+          .to be_a(described_class::BlockDefinition)
+      end
+
+      it 'initializes it correctly' do
+        expect(described_class.for(type, method_name, &block).name)
+          .to eq(method_name)
+      end
+    end
+
+    context 'when options are given' do
+      let(:type)        { :string }
+      let(:method_name) { :the_method }
+      let(:code)        { '10' }
+
+      it do
+        expect(described_class.for(type, method_name, code))
+          .to be_a(described_class)
+      end
+
+      it 'Returns an instance of the given type' do
+        expect(described_class.for(type, method_name, code))
+          .to be_a(described_class::StringDefinition)
+      end
+
+      it 'initializes it correctly' do
+        expect(described_class.for(type, method_name, code).name)
+          .to eq(method_name)
+      end
+    end
+  end
 end