sinclair 1.9.0 → 1.10.0

data/lib/sinclair/method_definition/string_definition.rb

@@ -5,8 +5,6 @@ class Sinclair
     # @api private
     # @author darthjee
     #
-    # @abstract
-    #
     # Define an instance method from string
     class StringDefinition < MethodDefinition
       # @param name    [String,Symbol] name of the method

data/lib/sinclair/method_definition.rb

@@ -11,6 +11,7 @@ class Sinclair
     autoload :BlockHelper,      'sinclair/method_definition/block_helper'
     autoload :BlockDefinition,  'sinclair/method_definition/block_definition'
     autoload :StringDefinition, 'sinclair/method_definition/string_definition'
+    autoload :CallDefinition,   'sinclair/method_definition/call_definition'
 
     # @method name
     #
@@ -24,31 +25,46 @@ class Sinclair
       cached: false
     }.freeze
 
-    # Builds a method that will return the same value always
-    #
-    # @return [Symbol]
-    def self.default_value(method_name, value)
-      define_method(method_name) { value }
-    end
+    class << self
+      # Builds a method that will return the same value always
+      #
+      # @return [Symbol]
+      def default_value(method_name, value)
+        define_method(method_name) { value }
+      end
 
-    # @param name    [String,Symbol] name of the method
-    # @param code    [String] code to be evaluated as method
-    # @param block   [Proc] block with code to be added as method
-    # @param options [Hash] Options of construction
-    # @option options cached [Boolean] Flag telling to create a block
-    #   with cache
-    #
-    # builds a method definition based on arguments
-    #
-    # when block is given, returns a {BlockDefinition} and
-    # returns a {StringDefinition} otherwise
-    #
-    # @return [Base]
-    def self.from(name, code = nil, **options, &block)
-      if block
-        BlockDefinition.new(name, **options, &block)
-      else
-        StringDefinition.new(name, code, **options)
+      # @param name    [String,Symbol] name of the method
+      # @param code    [String] code to be evaluated as method
+      # @param block   [Proc] block with code to be added as method
+      # @param options [Hash] Options of construction
+      # @option options cached [Boolean] Flag telling to create a block
+      #   with cache
+      #
+      # builds a method definition based on arguments
+      #
+      # when block is given, returns a {BlockDefinition} and
+      # returns a {StringDefinition} otherwise
+      #
+      # @return [Base]
+      def from(name, code = nil, **options, &block)
+        if block
+          BlockDefinition.new(name, **options, &block)
+        else
+          StringDefinition.new(name, code, **options)
+        end
+      end
+
+      # creates a definition
+      #
+      # The creation is based on type which will be used to infer
+      # which subclass of {Sinclair::MethodDefinition} to be used
+      #
+      # @param type [Symbol] the method definition type
+      #
+      # @return [Sinclair::MethodDefinition] an instance of a subclass
+      def for(type, *args, **options, &block)
+        klass = const_get("#{type}_definition".camelize)
+        klass.new(*args, **options, &block)
       end
     end
 

data/lib/sinclair/method_definitions.rb

@@ -10,6 +10,8 @@ class Sinclair
 
     # Builds and adds new definition
     #
+    # The type is decided based in the arguments
+    #
     # @param name [String,Symbol] method name
     # @param options [Hash] Options of construction
     # @option options cached [Boolean] Flag telling to create
@@ -21,11 +23,29 @@ class Sinclair
     # @overload add(definition_class, name, **options, &block)
     #   @param block [Proc]  block to be ran as method
     #
-    # @return MethodDefinitions
+    # @return [Array<MethodDefinition>]
     def add(name, code = nil, **options, &block)
       definitions << MethodDefinition.from(name, code, **options, &block)
     end
 
+    # Builds and adds new definition
+    #
+    # The type is decided based on the argument +type+
+    #
+    # @param type [Symbol] type of definition
+    #   - :string -> {MethodDefinition::StringDefinition}
+    #   - :block -> {MethodDefinition::BlockDefinition}
+    #   - :call -> {MethodDefinition::CallDefinition}
+    # @param options [Hash] Options of construction
+    # @option options cached [Boolean] Flag telling to create
+    #   a method with cache
+    # @param block [Proc]  block to be ran as method
+    #
+    # @return [Array<MethodDefinition>]
+    def add_definition(type, *args, **options, &block)
+      definitions << MethodDefinition.for(type, *args, **options, &block)
+    end
+
     private
 
     # @private

data/lib/sinclair/options/builder.rb

@@ -36,6 +36,7 @@ class Sinclair
       # @return (see Sinclair#build)
       def build
         add_all_methods
+        add_filds_to_equals
 
         super
       end
@@ -60,6 +61,13 @@ class Sinclair
           klass.allow(option)
         end
       end
+
+      # Add the fields to equals comparation
+      #
+      # @return (see Sinclair::EqualsChecker#add)
+      def add_filds_to_equals
+        klass.comparable_by(*attributes.keys)
+      end
     end
   end
 end

data/lib/sinclair/options.rb

@@ -24,6 +24,7 @@ class Sinclair
     autoload :ClassMethods, 'sinclair/options/class_methods'
 
     extend ClassMethods
+    include Comparable
 
     # @param options [Hash] hash with options (see {.options}, {.with_options})
     # @example (see Options)
@@ -59,19 +60,6 @@ class Sinclair
       end
     end
 
-    # returns if other equals to self
-    #
-    # @param other [Object] object to be compared
-    #
-    # @return [TrueClass,FalseClass]
-    def ==(other)
-      return false unless self.class == other.class
-
-      allowed_options.all? do |name|
-        public_send(name) == other.public_send(name)
-      end
-    end
-
     private
 
     delegate :allowed_options, :skip_validation?, :invalid_options_in, to: :class

data/lib/sinclair/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Sinclair
-  VERSION = '1.9.0'
+  VERSION = '1.10.0'
 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/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

data/spec/lib/sinclair/method_definition_spec.rb

@@ -42,4 +42,68 @@ describe Sinclair::MethodDefinition do
       end
     end
   end
+
+  describe '.for' 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(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(described_class.for(type, *arguments).code_string)
+          .to eq('attr_reader :some_attribute, :other_attribute')
+      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

data/spec/lib/sinclair/method_definitions_spec.rb

@@ -42,4 +42,83 @@ describe Sinclair::MethodDefinitions do
       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))
+          .to be_a(Array)
+      end
+
+      it 'creates a new definition' do
+        expect(definitions.add_definition(type, *arguments).last)
+          .to be_a(Sinclair::MethodDefinition)
+      end
+
+      it 'creates a new definition of the chosen type' do
+        expect(definitions.add_definition(type, *arguments).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')
+      end
+    end
+
+    context 'when a block is given' do
+      let(:type)        { :block }
+      let(:method_name) { :the_method }
+      let(:block)       { proc { 10 } }
+
+      it do
+        expect(definitions.add_definition(type, method_name, &block))
+          .to be_a(Array)
+      end
+
+      it 'creates a new definition' do
+        expect(definitions.add_definition(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)
+          .to be_a(Sinclair::MethodDefinition::BlockDefinition)
+      end
+
+      it 'initializes it correctly' do
+        expect(definitions.add_definition(type, method_name, &block).last.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(definitions.add_definition(type, method_name, code))
+          .to be_a(Array)
+      end
+
+      it 'creates a new definition' do
+        expect(definitions.add_definition(type, method_name, code).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)
+          .to be_a(Sinclair::MethodDefinition::StringDefinition)
+      end
+
+      it 'initializes it correctly' do
+        expect(definitions.add_definition(type, method_name, code).last.name)
+          .to eq(method_name)
+      end
+    end
+  end
 end

data/spec/lib/sinclair/options/builder_spec.rb

@@ -40,6 +40,19 @@ describe Sinclair::Options::Builder do
           .not_to change { Sinclair::Options.invalid_options_in(test_keys) }
       end
 
+      context 'when the object is compared with others' do
+        before { klass.skip_validation }
+
+        let(:options1) { klass.new(timeout: 10) }
+        let(:options2) { klass.new(timeout: 15) }
+
+        it 'adds the field to the equals check' do
+          expect { builder.build }
+            .to change { options1 == options2 }
+            .from(true).to(false)
+        end
+      end
+
       context 'when when calling method after building' do
         before { builder.build }