sinclair 1.10.0 → 1.11.0

data/spec/integration/readme/sinclair/types_of_definition_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair do
+  describe 'README' do
+    describe 'Define method using block' do
+      it 'adds the method' do
+        klass = Class.new
+        instance = klass.new
+
+        builder = described_class.new(klass)
+        builder.add_method(:random_number) { Random.rand(10..20) }
+        builder.build
+
+        expect(instance.random_number).to be_between(10, 20)
+      end
+    end
+
+    describe 'Define method using string' do
+      it 'adds the method' do
+        klass = Class.new
+        instance = klass.new
+
+        builder = described_class.new(klass)
+        builder.add_method(:random_number, 'Random.rand(10..20)')
+        builder.build
+
+        expect(instance.random_number).to be_between(10, 20)
+      end
+    end
+
+    describe 'Define method using call to the class' do
+      it 'performs the call to the class' do
+        klass = Class.new
+
+        builder = described_class.new(klass)
+        builder.add_class_method(:attr_accessor, :number, type: :call)
+        builder.build
+
+        expect(klass.number).to be_nil
+        klass.number = 10
+        expect(klass.number).to eq(10)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: false
+
+require 'spec_helper'
+
+describe 'yard Sinclair#add_class_method' do
+  let(:klass) { Class.new }
+
+  describe 'Adding a method by String' do
+    it 'returns the hostname' do
+      builder = Sinclair.new(klass)
+      builder.add_class_method(:hostname, 'ENV["HOSTNAME"]')
+      builder.build
+      ENV['HOSTNAME'] = 'myhost'
+
+      expect(klass.hostname).to eq('myhost')
+    end
+  end
+
+  describe 'Adding a method by Block' do
+    it 'returns the timeout' do
+      builder = Sinclair.new(klass)
+      builder.add_class_method(:timeout) { ENV['TIMEOUT'] }
+      builder.build
+      ENV['TIMEOUT'] = '300'
+
+      expect(klass.timeout).to eq('300')
+    end
+  end
+
+  describe 'Passing type block' do
+    it 'creates new method' do
+      builder = Sinclair.new(klass)
+      builder.add_class_method(:timeout, type: :block) { ENV['TIMEOUT'] }
+      builder.build
+      ENV['TIMEOUT'] = '300'
+
+      expect(klass.timeout).to eq('300')
+    end
+  end
+
+  describe 'Passing type call' do
+    it 'creates new method' do
+      builder = Sinclair.new(klass)
+      builder.add_class_method(:attr_accessor, :timeout, type: :call)
+      builder.build
+
+      klass.timeout = 10
+      expect(klass.timeout).to eq(10)
+    end
+  end
+end

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_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_definition/call_definition_spec.rb

@@ -10,27 +10,24 @@ describe Sinclair::MethodDefinition::CallDefinition do
   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)
+  describe '#code_block' do
+    let(:instance) { klass.new }
+    let(:klass) do
+      Class.new do
+        def method_call(*args)
+          args
+        end
+      end
     end
-  end
 
-  describe '#class_code_string' do
-    let(:expected) do
-      <<-RUBY
-      class << self
-        method_call :key1, :value2
-      end
-      RUBY
+    it do
+      expect(definition.code_block)
+        .to be_a(Proc)
     end
 
-    it 'returns the code string' do
-      expect(definition.class_code_string.gsub(/^ */, ''))
-        .to eq(expected.gsub(/^ */, ''))
+    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) }
 
@@ -44,6 +86,8 @@ describe Sinclair::MethodDefinition do
   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] }
@@ -59,8 +103,29 @@ describe Sinclair::MethodDefinition do
       end
 
       it 'initializes it correctly' do
-        expect(described_class.for(type, *arguments).code_string)
-          .to eq('attr_reader :some_attribute, :other_attribute')
+        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
 

data/spec/lib/sinclair/method_definitions_spec.rb

@@ -6,7 +6,8 @@ describe Sinclair::MethodDefinitions do
   subject(:definitions) { described_class.new }
 
   describe '#add' do
-    let(:name) { :the_method }
+    let(:name)  { :the_method }
+    let(:klass) { Class.new }
 
     context 'when passing block' do
       it 'returns the resulting array' do
@@ -41,31 +42,29 @@ describe Sinclair::MethodDefinitions do
           .to be_a(Sinclair::MethodDefinition::StringDefinition)
       end
     end
-  end
 
-  describe '#add_definition' do
     context 'when there are no options nor block' do
       let(:type)      { :call }
       let(:arguments) { %i[attr_reader some_attribute other_attribute] }
 
       it do
-        expect(definitions.add_definition(type, *arguments))
+        expect(definitions.add(*arguments, type: type))
           .to be_a(Array)
       end
 
       it 'creates a new definition' do
-        expect(definitions.add_definition(type, *arguments).last)
+        expect(definitions.add(*arguments, type: type).last)
           .to be_a(Sinclair::MethodDefinition)
       end
 
       it 'creates a new definition of the chosen type' do
-        expect(definitions.add_definition(type, *arguments).last)
+        expect(definitions.add(*arguments, type: type).last)
           .to be_a(Sinclair::MethodDefinition::CallDefinition)
       end
 
       it 'initializes it correctly' do
-        expect(definitions.add_definition(type, *arguments).last.code_string)
-          .to eq('attr_reader :some_attribute, :other_attribute')
+        expect { klass.module_eval(&definitions.add(*arguments, type: type).last.code_block) }
+          .to add_method(:some_attribute).to(klass)
       end
     end
 
@@ -75,22 +74,22 @@ describe Sinclair::MethodDefinitions do
       let(:block)       { proc { 10 } }
 
       it do
-        expect(definitions.add_definition(type, method_name, &block))
+        expect(definitions.add(type, method_name, &block))
           .to be_a(Array)
       end
 
       it 'creates a new definition' do
-        expect(definitions.add_definition(type, method_name, &block).last)
+        expect(definitions.add(type, method_name, &block).last)
           .to be_a(Sinclair::MethodDefinition)
       end
 
       it 'creates a new definition of the chosen type' do
-        expect(definitions.add_definition(type, method_name, &block).last)
+        expect(definitions.add(type, method_name, &block).last)
           .to be_a(Sinclair::MethodDefinition::BlockDefinition)
       end
 
       it 'initializes it correctly' do
-        expect(definitions.add_definition(type, method_name, &block).last.name)
+        expect(definitions.add(method_name, type: type, &block).last.name)
           .to eq(method_name)
       end
     end
@@ -101,22 +100,22 @@ describe Sinclair::MethodDefinitions do
       let(:code)        { '10' }
 
       it do
-        expect(definitions.add_definition(type, method_name, code))
+        expect(definitions.add(method_name, code, type: type))
           .to be_a(Array)
       end
 
       it 'creates a new definition' do
-        expect(definitions.add_definition(type, method_name, code).last)
+        expect(definitions.add(method_name, code, type: type).last)
           .to be_a(Sinclair::MethodDefinition)
       end
 
       it 'creates a new definition of the chosen type' do
-        expect(definitions.add_definition(type, method_name, code).last)
+        expect(definitions.add(method_name, code, type: type).last)
           .to be_a(Sinclair::MethodDefinition::StringDefinition)
       end
 
       it 'initializes it correctly' do
-        expect(definitions.add_definition(type, method_name, code).last.name)
+        expect(definitions.add(method_name, code, type: type).last.name)
           .to eq(method_name)
       end
     end