sinclair 1.6.2 → 1.6.7

data/lib/sinclair/matchers/method_to.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+class Sinclair
+  module Matchers
+    # @api private
+    #
+    # Common methods on final matchers
+    module MethodTo
+      # Used for other versions of rspec
+      #
+      # Some versions call failure_message, others
+      # call failure_message_for_should
+      #
+      # @return [String]
+      def failure_message
+        failure_message_for_should
+      end
+
+      # Used for other versions of rspec
+      #
+      # Some versions call failure_message_when_negated, others
+      # call failure_message_for_should_not
+      #
+      # @return [String]
+      def failure_message_when_negated
+        failure_message_for_should_not
+      end
+
+      # Checks if expectation is true or not
+      #
+      # @return [Boolean] expectation check
+      def matches?(event_proc)
+        return false unless event_proc.is_a?(Proc)
+
+        raise_block_syntax_error if block_given?
+        perform_change(event_proc)
+        check
+      end
+
+      protected
+
+      # @method klass
+      # @api private
+      # @private
+      #
+      # Class where class method should be added to
+      #
+      # @return [Class]
+      attr_reader :klass
+
+      private
+
+      # @method initial_state
+      # @api private
+      # @private
+      #
+      # State before running the block
+      #
+      # @return [Object]
+
+      # @method final_state
+      # @api private
+      # @private
+      #
+      # State after running the block
+      #
+      # @return [Object]
+      attr_reader :initial_state, :final_state
+
+      # @private
+      #
+      # Call block to check if it aded a method or not
+      #
+      # @return [Boolan]
+      def perform_change(event_proc)
+        @initial_state = state
+        event_proc.call
+        @final_state = state
+      end
+    end
+  end
+end

data/lib/sinclair/options.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'set'
+
 class Sinclair
   # @api public
   # @author Darthjee
@@ -18,52 +20,10 @@ class Sinclair
   #   options.port     # returns 8080
   #   options.protocol # returns 'https'
   class Options
-    autoload :Builder, 'sinclair/options/builder'
-
-    class << self
-      # @api private
-      # @private
-      #
-      # Options allowed when initializing options
-      #
-      # @return [Array<Symbol>]
-      def allowed_options
-        @allowed_options ||= (superclass.try(:allowed_options).dup || [])
-      end
-
-      # @api private
-      # @private
-      #
-      # returns invalid options
-      #
-      # @return [Array<Symbol>]
-      def invalid_options_in(names)
-        names.map(&:to_sym) - allowed_options
-      end
-
-      private
+    autoload :Builder,      'sinclair/options/builder'
+    autoload :ClassMethods, 'sinclair/options/class_methods'
 
-      # @api public
-      # @!visibility public
-      #
-      # Add available options
-      #
-      # @example (see Options)
-      #
-      # @return (see Sinclair#build)
-      #
-      # @overload with_options(*options)
-      #   @param options [Array<Symbol>] list of accepted
-      #     options
-      # @overload with_options(*options, **defaults)
-      #   @param options [Array<Symbol>] list of accepted
-      #     options
-      #   @param defaults [Hash<Symbol,Object>] default options
-      #     hash
-      def with_options(*options)
-        Builder.new(self, *options).build
-      end
-    end
+    extend ClassMethods
 
     # @param options [Hash] hash with options (see {.options}, {.with_options})
     # @example (see Options)
@@ -75,8 +35,47 @@ class Sinclair
       end
     end
 
+    # Returns a hash with the current options
+    #
+    # @return [Hash]
+    #
+    # @example
+    #   class ConnectionOptions < Sinclair::Options
+    #     with_options :timeout, :retries, port: 443, protocol: 'https'
+    #   end
+    #
+    #   options = ConnectionOptions.new(retries: 10, port: 8080)
+    #
+    #   options.to_h # returns
+    #                # {
+    #                #   port: 8080,
+    #                #   retries: 10,
+    #                #   timeout: nil,
+    #                #   protocol: 'https'
+    #                # }
+    def to_h
+      allowed_options.inject({}) do |hash, option|
+        hash.merge(option => public_send(option))
+      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
+
     # @private
     # @api private
     #
@@ -86,7 +85,9 @@ class Sinclair
     #
     # @return [NilClass]
     def check_options(options)
-      invalid_keys = self.class.invalid_options_in(options.keys)
+      return if skip_validation?
+
+      invalid_keys = invalid_options_in(options.keys)
 
       return if invalid_keys.empty?
 

data/lib/sinclair/options/builder.rb

@@ -57,7 +57,7 @@ class Sinclair
       def add_all_methods
         attributes.each do |option, value|
           add_method(option, cached: :full) { value }
-          klass.allowed_options.push(option.to_sym)
+          klass.allow(option)
         end
       end
     end

data/lib/sinclair/options/class_methods.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'set'
+
+class Sinclair
+  class Options
+    # Class Methods for {Sinclai::Options}
+    module ClassMethods
+      # @api private
+      #
+      # returns invalid options
+      #
+      # @return [Array<Symbol>]
+      def invalid_options_in(names)
+        names.map(&:to_sym) - allowed_options.to_a
+      end
+
+      # @api private
+      #
+      # Allow new option
+      #
+      # This does not create the method
+      #
+      # @param name [String,Symbol] options to be allowed
+      #
+      # @return [Set<Symbol>]
+      def allow(name)
+        allowed_options << name.to_sym
+      end
+
+      # @api private
+      # @private
+      #
+      # Options allowed when initializing options
+      #
+      # @return [Set<Symbol>]
+      def allowed_options
+        @allowed_options ||= superclass.try(:allowed_options).dup || Set.new
+      end
+
+      # @api private
+      #
+      # checks if class skips initialization validation
+      #
+      # @return [TrueClass,FalseClass]
+      def skip_validation?
+        @skip_validation ||= superclass.try(:skip_validation?) || false
+      end
+
+      private
+
+      # @api public
+      # @!visibility public
+      #
+      # Add available options
+      #
+      # @example (see Options)
+      #
+      # @return (see Sinclair#build)
+      #
+      # @overload with_options(*options)
+      #   @param options [Array<Symbol>] list of accepted
+      #     options
+      # @overload with_options(*options, **defaults)
+      #   @param options [Array<Symbol>] list of accepted
+      #     options
+      #   @param defaults [Hash<Symbol,Object>] default options
+      #     hash
+      def with_options(*options)
+        Builder.new(self, *options).build
+      end
+
+      # @api public
+      # @!visibility public
+      #
+      # Changes class to skip attributes validation
+      #
+      # when initializing options, options
+      # will accept any arguments when validation
+      # is skipped
+      #
+      # @return [TrueClass]
+      #
+      # @example
+      #   class BuilderOptions < Sinclair::Options
+      #     with_options :name
+      #
+      #     skip_validation
+      #   end
+      #   options = BuilderOptions.new(name: 'Joe', age: 10)
+      #
+      #   options.name      # returns 'Joe'
+      #   options.try(:age) # returns nil
+      def skip_validation
+        @skip_validation = true
+      end
+    end
+  end
+end

data/lib/sinclair/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Sinclair
-  VERSION = '1.6.2'
+  VERSION = '1.6.7'
 end

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

@@ -15,5 +15,13 @@ describe Sinclair::Options do
       expect(options.protocol).to eq('http')
       expect(options.port).to eq(443)
     end
+
+    context 'when initialized with invalid options' do
+      it do
+        expect do
+          ConnectionOptions.new(invalid: 10)
+        end.to raise_error(Sinclair::Exception::InvalidOptions)
+      end
+    end
   end
 end

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/integration/yard/sinclair/options_spec.rb

@@ -4,13 +4,24 @@ require 'spec_helper'
 
 describe Sinclair::Options do
   describe 'yard' do
-    it 'creates options object' do
-      options = ConnectionOptions.new(retries: 10, port: 8080)
+    describe 'usage' do
+      it 'creates options object' do
+        options = ConnectionOptions.new(retries: 10, port: 8080)
 
-      expect(options.timeout).to be_nil
-      expect(options.retries).to eq(10)
-      expect(options.port).to eq(8080)
-      expect(options.protocol).to eq('https')
+        expect(options.timeout).to be_nil
+        expect(options.retries).to eq(10)
+        expect(options.port).to eq(8080)
+        expect(options.protocol).to eq('https')
+      end
+    end
+
+    describe '#to_h' do
+      it 'returns options hash' do
+        options = ConnectionOptions.new(retries: 10, port: 8080)
+
+        expect(options.to_h)
+          .to eq({ port: 8080, retries: 10, timeout: nil, protocol: 'https' })
+      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