sinclair 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5d1b06127b9390b635b3f51e208b4e0e327e37bf3a983975256c998746c19ef
-  data.tar.gz: c9ef323396888f3adbf13b1f2147856987c0ffb4f4ea05e8419f0440f2445c25
+  metadata.gz: 8078be623117ced163bf463e484e1e2553781dc3ebf379e48a98dc5c3e710079
+  data.tar.gz: 5edfd7356786a04ee94f5bfff56fd954e26b52b5fa4ef7eb3372ddd33ddb6c80
 SHA512:
-  metadata.gz: a70f4147f03c3ef11467af1c5de31c4fa446368496126ce588875016cbbac17287f3c736c7d040b42e5f6cbff797cdfb1b5002db4475451541114486a554b14e
-  data.tar.gz: 824f2cf65e9442e002b8010e4ed2f2ba3228043cba122358538aa497cc0015b1ea64a6acac1bce68f8f321d1c1c624ce27e97030775554bca9b33ec55da76671
+  metadata.gz: 03b32dcf796be1331442a673040264bc2cb215f1ad2eb657aaf416f76bea0e6aaca71ccb8bd356e5c9ab094dc31f4d2a0c3cc4dc607ccb39db429b864b5e785c
+  data.tar.gz: 28bd3ed7dea51f96d82bdbbdb64588762cc017ab92d8847045dbf33beb8aa83abc71869ff5e55f4f8dc72f4f29f4f9907596702acb7ab5f456c43bc0b92e902b

data/.circleci/config.yml

@@ -2,7 +2,7 @@ version: 2
 jobs:
   build:
     docker:
-      - image: darthjee/circleci_ruby_gems:0.0.1
+      - image: darthjee/circleci_ruby_gems:0.1.0
     steps:
       - checkout
       - run:
@@ -26,3 +26,6 @@ jobs:
       - run:
           name: Check version documentation
           command: scripts/check_readme.sh
+      - run:
+          name: Rubycritcs check
+          command: scripts/rubycritic.sh

data/.gitignore

@@ -6,3 +6,4 @@ doc
 .yardoc/
 measurement/
 **/*.swp
+rubycritic/

data/Dockerfile

@@ -1,6 +1,26 @@
-FROM darthjee/ruby_gems:0.0.1
+FROM darthjee/ruby_gems:0.0.1 as base
+FROM darthjee/scripts:0.0.2 as scripts
+
+######################################
+
+FROM base as builder
 
-USER app
 COPY --chown=app ./ /home/app/app/
+COPY --chown=app:app --from=scripts /home/scripts/ ./
+
+ENV HOME_DIR /home/app
+RUN /bin/bash bundle_builder.sh
 
-RUN bundle install
+#######################
+#FINAL IMAGE
+FROM base
+
+USER root
+
+COPY --chown=app:app --from=builder /home/app/bundle/gems /usr/local/bundle/gems
+COPY --chown=app:app --from=builder /home/app/bundle/cache /usr/local/bundle/cache
+COPY --chown=app:app --from=builder /home/app/bundle/specifications /usr/local/bundle/specifications
+COPY --chown=app:app --from=builder /home/app/bundle/bin /usr/local/bundle/bin
+COPY --chown=app:app --from=builder /home/app/bundle/extensions /usr/local/bundle/extensions
+
+USER app

data/README.md

@@ -12,7 +12,7 @@ This gem helps the creation of complex concern with class methods
 
 Yard Documentation
 -------------------
-https://www.rubydoc.info/gems/sinclair/1.2.1
+https://www.rubydoc.info/gems/sinclair/1.3.0
 
 Installation
 ---------------

data/Rakefile

@@ -4,6 +4,7 @@ require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'yardstick/rake/measurement'
 require './config/yardstick'
+require './config/rubycritc'
 
 RSpec::Core::RakeTask.new
 

data/config/rubycritc.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rubycritic/rake_task'
+
+RubyCritic::RakeTask.new do |task|
+  options = %w[
+    --path rubycritic/
+    --no-browser
+  ]
+  task.options = options.join(' ')
+  task.paths   = %w[lib]
+end

data/config/yardstick.yml

@@ -31,6 +31,9 @@ rules:
       - Sinclair::OptionsParser#options
       - Sinclair::OptionsParser#options_object
       - Sinclair::Matchers::AddMethodTo#raise_block_syntax_error
+      - Sinclair::ConfigFactory#initialize
+      - Sinclair::ConfigFactory#config_class
+      - Sinclair::ConfigFactory#config_attributes
   Summary::Presence:
     enabled: true
     exclude:
@@ -43,6 +46,9 @@ rules:
       - Sinclair::MethodDefinition#block
       - Sinclair::OptionsParser#options
       - Sinclair::OptionsParser#options_object
+      - Sinclair::ConfigFactory#initialize
+      - Sinclair::ConfigFactory#config_class
+      - Sinclair::ConfigFactory#config_attributes
   Summary::Length:
     enabled: true
     exclude: []

data/lib/sinclair/config.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Sinclair
+  # Base class for configuration when using {Configurable}
+  #
+  # The methods will be added later by {ConfigFactory}
+  #
+  # The instance variables will be set by {ConfigBuilder}
+  class Config
+  end
+end

data/lib/sinclair/config_builder.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class Sinclair
+  # @api private
+  #
+  # Class responsible for setting the values on configuration
+  #
+  # @example
+  #   class MyConfig
+  #     attr_reader :name, :config
+  #   end
+  #
+  #   config = MyConfig.new
+  #
+  #   builder = Sinclair::ConfigBuilder.new(config, :name)
+  #
+  #   builder.instance_eval { |c| c.name 'John' }
+  #
+  #   config.name # returns 'John'
+  class ConfigBuilder
+    # A new instance of ConfigBuilder
+    #
+    # @param config [Sinclair::Config] config object to be build
+    #   config object has no attribute setters (only readers)
+    #   so all attributes are set as instance variable
+    #
+    # @param config_attributes [Array<Symbol>] list of attributes
+    #   that can be set on config (expecting that config has
+    #   the right attribute readers)
+    def initialize(config, *config_attributes)
+      @config = config
+      @config_attributes = config_attributes
+    end
+
+    private
+
+    # @private
+    #
+    # Method called for methods missing
+    #
+    # When a method is missing, it is expected that it is the
+    # name of a variable to be set on config (as long as it was
+    # defined in the config_attributes_array)
+    #
+    # @param method_name [Symbol] name of the method called
+    # @param args [Array<Object>] arguments of the call
+    #
+    # @return [Object]
+    def method_missing(method_name, *args)
+      return super unless @config_attributes.include?(method_name)
+
+      @config.instance_variable_set("@#{method_name}", *args)
+    end
+
+    # @private
+    #
+    # Checks if method missing will catch the method called
+    #
+    # @return [TrueClass,FalseClass]
+    #
+    # @see #method_missing
+    def respond_to_missing?(method_name, include_private)
+      @config_attributes.include?(method_name) || super
+    end
+  end
+end

data/lib/sinclair/config_factory.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+class Sinclair
+  # @api private
+  #
+  # Class responsible for configuring the configuration class
+  #
+  # @example General usage
+  #   factory = Sinclair::ConfigFactory.new
+  #   factory.add_configs(:name)
+  #   factory.configure { |c| c.name 'John' }
+  #
+  #   config = factory.config
+  #
+  #   config.class.superclass       # returns Sinclair::Config
+  #   factory.config.equal?(config) # returns true
+  #   config.name                   # returns 'John'
+  class ConfigFactory
+    # @param config_class [Class] configuration class to be used
+    # @param config_attributes [Array<Symbol,String>] list of possible configurations
+    def initialize(config_class: Class.new(Config), config_attributes: [])
+      @config_class = config_class
+      @config_attributes = config_attributes.dup
+    end
+
+    # Returns current instance of config
+    #
+    # the method returns the same instance until +reset_config+
+    # is called
+    #
+    # @return [Config,Object] the instance of given
+    #   config_class. by default, this returns
+    #   +Class.new(Config).new+
+    #
+    # @see #reset_config
+    #
+    # @example (see ConfigFactory)
+    def config
+      @config ||= config_class.new
+    end
+
+    # Cleans the current config instance
+    #
+    # After cleaning it, {#config} will generate a new
+    # instance
+    #
+    # @return [NilClass]
+    #
+    # @example
+    #   factory = Sinclair::ConfigFactory.new
+    #
+    #   config = factory.config
+    #
+    #   factory.reset_config
+    #
+    #   factory.config == config # returns false
+    def reset_config
+      @config = nil
+    end
+
+    # Adds possible configurations
+    #
+    # It change the configuration class adding methods
+    #   and keeps track of those configurations so that
+    #   {ConfigBuilder} is able to set those values when invoked
+    #
+    # @return [Array<Symbol>] all known config attributes
+    #
+    # @example Adding configuration name
+    #   factory = Sinclair::ConfigFactory.new
+    #   config = factory.config
+    #
+    #   config.respond_to? :active
+    #   # returns false
+    #
+    #   factory.add_configs(:active)
+    #
+    #   config.respond_to? :active
+    #   # returns true
+    def add_configs(*attributes)
+      config_class.attr_reader(*attributes)
+      config_attributes.concat(attributes.map(&:to_sym))
+    end
+
+    # Set the values in the config
+    #
+    # The block given is evaluated by the {ConfigBuilder}
+    # where each method missed will be used to set a variable
+    # in the config
+    #
+    # @yield [ConfigBuilder] methods called in the block
+    #   that are not present in {ConfigBuilder} are
+    #   then set as instance variables of the config
+    #
+    # @return [Object] the result of the block
+    #
+    # @example Setting name on config
+    #   class MyConfig
+    #     attr_reader :name
+    #   end
+    #
+    #   factory = Sinclair::ConfigFactory.new(
+    #     config_class: MyConfig,
+    #     config_attributes: [:name]
+    #   )
+    #
+    #   config = factory.config
+    #
+    #   factory.configure { name 'John' }
+    #
+    #   config.name # returns 'John'
+    def configure(&block)
+      config_builder.instance_eval(&block)
+    end
+
+    # Returns a new instance of ConfigFactory
+    #
+    # the new instance will have the same
+    # config_attributes and for config_class a child
+    # of the current config_class
+    #
+    # This method is called when initializing {Configurable}
+    # config_factory and the superclass is also configurable
+    #
+    # This way, child classes from other {Configurable} classes
+    # will have a config_class that is a child from the original
+    # config_class
+    #
+    # @return [ConfigFactory]
+    def child
+      self.class.new(
+        config_class: Class.new(config_class),
+        config_attributes: config_attributes
+      )
+    end
+
+    private
+
+    # @private
+    attr_reader :config_class, :config_attributes
+
+    # @private
+    #
+    # Returns a builder capable of injecting variables into config
+    #
+    # @return [ConfigBuilder]
+    def config_builder
+      ConfigBuilder.new(config, *config_attributes)
+    end
+  end
+end

data/lib/sinclair/configurable.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+class Sinclair
+  # @api public
+  #
+  # Module capable of giving configuration capability
+  #
+  # By extending Configurable, class receives the methods public
+  # {ConfigFactory#config .config}, {ConfigFactory#reset_config .reset_config}
+  # and {ConfigFactory#configure .configure}
+  # and the private {#configurable_with .configurable_with}
+  #
+  # @see ConfigFactory
+  # @see ConfigBuilder
+  #
+  # @example
+  #   class MyConfigurable
+  #     extend Sinclair::Configurable
+  #
+  #     configurable_with :host, :port
+  #   end
+  #
+  #   MyConfigurable.configure do
+  #     host 'interstella.com'
+  #     port 5555
+  #   end
+  #
+  #   MyConfigurable.config.host
+  #   # returns 'interstella.com'
+  #
+  #   MyConfigurable.config.port
+  #   # returns 5555
+  #
+  #   MyConfigurable.reset
+  #
+  #   MyConfigurable.config.host
+  #   # returns nil
+  module Configurable
+    delegate :config, :reset_config, :configure, to: :config_factory
+
+    protected
+
+    # @api private
+    #
+    # @private
+    #
+    # Generates a config factory
+    #
+    # When the current class is a child of a class extending
+    # {Configurable}, config_factory will be initialized with
+    # parameters to generate a configuration child from the
+    # original factory config
+    #
+    # @see ConfigFactory#child
+    #
+    # @return [ConfigFactory]
+    def config_factory
+      @config_factory ||= if superclass.is_a?(Configurable)
+                            superclass.config_factory.child
+                          else
+                            ConfigFactory.new
+                          end
+    end
+
+    private
+
+    # @visibility public
+    #
+    # Adds a configuration option to config class
+    #
+    # @return [Array<Symbol>] list of possible
+    #   configurations
+    #
+    # @see ConfigFactory#add_configs
+    #
+    # @example (see Configurable)
+    def configurable_with(*attributes)
+      config_factory.add_configs(*attributes)
+    end
+  end
+end

data/lib/sinclair/version.rb

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

data/lib/sinclair.rb

@@ -29,6 +29,10 @@ class Sinclair
 
   autoload :VERSION,          'sinclair/version'
   autoload :MethodDefinition, 'sinclair/method_definition'
+  autoload :Config,           'sinclair/config'
+  autoload :ConfigBuilder,    'sinclair/config_builder'
+  autoload :ConfigFactory,    'sinclair/config_factory'
+  autoload :Configurable,     'sinclair/configurable'
 
   include OptionsParser
 

data/scripts/rubycritic.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+DIFF_LIST=$(git diff --name-only $CIRCLE_SHA1 $(git merge-base $CIRCLE_SHA1 origin/master) | grep "^lib/")
+
+if [ ! -z "$DIFF_LIST" ]; then
+  mkdir -p tmp/rubycritic/compare
+  bundle exec rubycritic --format console --branch origin/master -t 0 $DIFF_LIST
+else
+  echo "No changes detected. Skipping rubycritic..."
+fi

data/sinclair.gemspec

@@ -27,6 +27,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rspec',         '>= 3.8'
   gem.add_development_dependency 'rubocop',       '0.58.1'
   gem.add_development_dependency 'rubocop-rspec', '1.30.0'
+  gem.add_development_dependency 'rubycritic',    '>= 4.0.2'
   gem.add_development_dependency 'simplecov',     '~> 0.16.x'
   gem.add_development_dependency 'yard',          '>= 0.9.18'
   gem.add_development_dependency 'yardstick',     '>= 0.9.9'

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+describe Sinclair::ConfigBuilder do
+  describe 'yard' do
+    describe '#instance_eval' do
+      subject(:builder) do
+        described_class.new(config, :name)
+      end
+
+      let(:config) { MyConfig.new }
+
+      it 'sets variable from config' do
+        expect { builder.instance_eval { |c| c.name 'John' } }
+          .to change(config, :name)
+          .from(nil).to('John')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+describe Sinclair::ConfigFactory do
+  describe '#yard' do
+    subject(:factory) do
+      described_class.new(
+        config_class: config_class,
+        config_attributes: config_attributes
+      )
+    end
+
+    let(:config_class)      { Class.new(Sinclair::Config) }
+    let(:config_attributes) { [:name] }
+    let(:config)            { factory.config }
+
+    describe 'general usage' do
+      context 'when not passing any argument' do
+        subject(:factory) { described_class.new }
+
+        before do
+          factory.add_configs(:name)
+          factory.configure { |c| c.name 'John' }
+        end
+
+        it 'returns an instance of Config child class' do
+          expect(config.class.superclass)
+            .to eq(Sinclair::Config)
+        end
+
+        it 'configures name to be John' do
+          expect(config.name).to eq('John')
+        end
+
+        it 'returns always the same instance' do
+          expect(factory.config).to be_equal(config)
+        end
+      end
+    end
+
+    describe '#reset_config' do
+      it 'changes config instance' do
+        expect { factory.reset_config }
+          .to change(factory, :config)
+      end
+    end
+
+    describe '#add_configs' do
+      let(:config) { factory.config }
+
+      context 'when it already have config_attributes' do
+        it 'returns current possible configurations' do
+          expect(factory.add_configs('active'))
+            .to eq(%i[name active])
+        end
+      end
+
+      context 'when initializing with no parameters' do
+        subject(:factory) { described_class.new }
+
+        it 'adds method to config' do
+          expect { factory.add_configs(:active) }
+            .to change { config.respond_to?(:active) }
+            .from(false).to(true)
+        end
+      end
+    end
+
+    describe '#configure' do
+      let(:config_class) { MyConfig }
+
+      it 'sets variable on config' do
+        expect { factory.configure { name 'John' } }
+          .to change(config, :name)
+          .from(nil).to('John')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+describe Sinclair::Configurable do
+  describe '#yard' do
+    before do
+      MyConfigurable.configure do
+        host 'interstella.com'
+        port 5555
+      end
+    end
+
+    it 'sets right value for config host' do
+      expect(MyConfigurable.config.host)
+        .to eq('interstella.com')
+    end
+
+    it 'sets right value for config port' do
+      expect(MyConfigurable.config.port)
+        .to eq(5555)
+    end
+
+    context 'when reset_config is called' do
+      before { MyConfigurable.reset_config }
+
+      it 'returns initial value for host' do
+        expect(MyConfigurable.config.host)
+          .to be_nil
+      end
+    end
+  end
+end

data/spec/lib/sinclair/config_builder_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+describe Sinclair::ConfigBuilder do
+  subject(:builder) { described_class.new(config, *config_attributes) }
+
+  let(:config)            { MyConfig.new }
+  let(:config_attributes) { [:name] }
+
+  it 'changes responds to given config' do
+    expect(builder).to respond_to(:name)
+  end
+
+  it 'does not respond to othr configs' do
+    expect(builder).not_to respond_to(:other_method)
+  end
+
+  it 'responds to other parent methods' do
+    expect(builder).to respond_to(:to_s)
+  end
+
+  context 'when builder was configuratd with the method called' do
+    let(:config_attributes) { [:name] }
+
+    it 'sets the instance variable' do
+      expect { builder.name 'John' }
+        .to change(config, :name)
+        .from(nil).to('John')
+    end
+  end
+
+  context 'when builder was configuratd without the method called' do
+    let(:config_attributes) { [] }
+
+    it 'does not set the instance variable and raises error' do
+      expect { builder.name 'John' }
+        .to raise_error(NoMethodError)
+        .and not_change(config, :name)
+    end
+  end
+
+  context 'when using a variable name from builder variables' do
+    let(:config_attributes) { [:config] }
+
+    it 'sets the instance variable without changing builder instance variable' do
+      expect { builder.config(key: 'value') }
+        .to not_change { builder.instance_variable_get(:@config) }
+        .and change(config, :config)
+        .from(nil).to(key: 'value')
+    end
+  end
+end

data/spec/lib/sinclair/config_factory_spec.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::ConfigFactory do
+  subject(:factory) { described_class.new }
+
+  let(:config)        { factory.config }
+  let(:other_factory) { described_class.new }
+
+  describe '#config' do
+    it do
+      expect(factory.config).to be_a(Sinclair::Config)
+    end
+
+    context 'when calling twice' do
+      it 'returns the same instance' do
+        expect(factory.config)
+          .to be(factory.config)
+      end
+    end
+
+    context 'when calling after reset_config' do
+      before { factory.reset_config }
+
+      it do
+        expect(factory.config).to be_a(Sinclair::Config)
+      end
+    end
+
+    context 'when initializing with custom config class' do
+      subject(:factory) { described_class.new(config_class: DummyConfig) }
+
+      it do
+        expect(factory.config).to be_a(DummyConfig)
+      end
+
+      context 'when calling after reset_config' do
+        before { factory.reset_config }
+
+        it do
+          expect(factory.config).to be_a(DummyConfig)
+        end
+      end
+    end
+  end
+
+  describe '#reset_config' do
+    let(:old_instance) { factory.config }
+
+    it 'reset_configs instance' do
+      expect { factory.reset_config }
+        .to change { factory.config.eql?(old_instance) }
+        .from(true).to(false)
+    end
+
+    it 'forces regeneration of instance' do
+      expect { factory.reset_config }
+        .not_to change { factory.config.class }
+    end
+
+    context 'when initializing with custom config class' do
+      subject(:factory) { described_class.new(config_class: DummyConfig) }
+
+      it 'reset_configs instance' do
+        expect { factory.reset_config }
+          .to change { factory.config.eql?(old_instance) }
+          .from(true).to(false)
+      end
+
+      it 'forces regeneration of instance' do
+        expect { factory.reset_config }
+          .not_to change { factory.config.class }
+      end
+
+      it 'does not affect other factories' do
+        expect { factory.reset_config }
+          .not_to change(other_factory, :config)
+      end
+    end
+  end
+
+  describe '#add_configs' do
+    it 'adds reader to config' do
+      expect { factory.add_configs(:name) }
+        .to add_method(:name).to(factory.config)
+    end
+
+    it 'does not add setter to config' do
+      expect { factory.add_configs(:name) }
+        .not_to add_method(:name=).to(factory.config)
+    end
+
+    it 'does not change Sinclair::Config class' do
+      expect { factory.add_configs(:name) }
+        .not_to add_method(:name).to(Sinclair::Config.new)
+    end
+
+    it 'allows config_builder to handle method missing' do
+      factory.add_configs(:name)
+      expect { factory.configure { name 'John' } }.not_to raise_error
+    end
+
+    it 'changes subclasses of config' do
+      expect { factory.add_configs(:name) }
+        .to add_method(:name).to(factory.child.config)
+    end
+
+    it 'does not mess with parent config_builder' do
+      factory.child.add_configs(:name)
+      expect { factory.configure { name 'John' } }
+        .to raise_error(NoMethodError)
+    end
+
+    context 'when initializing with custom config class' do
+      it do
+        expect { factory.add_configs(:name) }
+          .to add_method(:name).to(factory.config)
+      end
+
+      it 'does not change other config classes' do
+        expect { factory.add_configs(:name) }
+          .not_to add_method(:name).to(other_factory.config)
+      end
+    end
+
+    it 'does not mess with configurable methods' do
+      factory.add_configs(:reset_config)
+      factory.configure { |c| c.reset_config true }
+      factory.reset_config
+      expect(factory.config).to be_a(Sinclair::Config)
+    end
+  end
+
+  describe '#configure' do
+    before { factory.add_configs(:user, 'password') }
+
+    it do
+      expect { factory.configure { |c| c.user 'Bob' } }
+        .to change(config, :user)
+        .from(nil).to('Bob')
+    end
+
+    context 'when it was defined using string' do
+      it do
+        expect { factory.configure { |c| c.password '123456' } }
+          .to change(config, :password)
+          .from(nil).to('123456')
+      end
+    end
+
+    context 'when calling a method that was not defined' do
+      it do
+        expect { factory.configure { |c| c.nope '123456' } }
+          .to raise_error(NoMethodError)
+      end
+    end
+  end
+
+  describe '#child' do
+    it { expect(factory.child).to be_a(described_class) }
+
+    it 'generates factory capable of generating config subclasses' do
+      expect(factory.child.config).to be_a(factory.config.class)
+    end
+
+    it 'generates factory that does not generate same config class' do
+      expect(factory.child.config.class).not_to eq(factory.config.class)
+    end
+  end
+end

data/spec/lib/sinclair/configurable_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Configurable do
+  subject(:configurable) { Class.new(DummyConfigurable) }
+
+  describe '.config' do
+    it do
+      expect(configurable.config).to be_a(Sinclair::Config)
+    end
+
+    context 'when calling twice' do
+      it 'returns the same instance' do
+        expect(configurable.config)
+          .to be(configurable.config)
+      end
+    end
+
+    context 'when calling after reset_config' do
+      before { configurable.reset_config }
+
+      it do
+        expect(configurable.config).to be_a(Sinclair::Config)
+      end
+    end
+  end
+
+  describe '.reset_config' do
+    let(:old_instance) { configurable.config }
+
+    it 'reset_configs instance' do
+      expect { configurable.reset_config }
+        .to change { configurable.config.eql?(old_instance) }
+        .from(true).to(false)
+    end
+
+    it 'forces regeneration of instance' do
+      expect { configurable.reset_config }
+        .not_to change { configurable.config.class }
+    end
+  end
+
+  describe '.configurable_with' do
+    it 'adds reader to config' do
+      expect { configurable.send(:configurable_with, :name) }
+        .to add_method(:name).to(configurable.config)
+    end
+
+    it 'does not add setter to config' do
+      expect { configurable.send(:configurable_with, :name) }
+        .not_to add_method(:name=).to(configurable.config)
+    end
+
+    it 'does not change parent class configuration' do
+      expect { configurable.send(:configurable_with, :name) }
+        .not_to add_method(:name).to(DummyConfigurable.config)
+    end
+
+    it 'does not change Sinclair::Config' do
+      expect { configurable.send(:configurable_with, :name) }
+        .not_to add_method(:name).to(Sinclair::Config.new)
+    end
+
+    it 'does not mess with configurable methods' do
+      configurable.send(:configurable_with, :reset_config)
+      configurable.configure { |c| c.reset_config true }
+      configurable.reset_config
+      expect(configurable.config).to be_a(Sinclair::Config)
+    end
+  end
+
+  describe '.configure' do
+    let(:config) { configurable.config }
+
+    it do
+      expect { configurable.configure { |c| c.user 'Bob' } }
+        .to change(config, :user)
+        .from(nil).to('Bob')
+    end
+
+    context 'when it was defined using string' do
+      it do
+        expect { configurable.configure { |c| c.password '123456' } }
+          .to change(config, :password)
+          .from(nil).to('123456')
+      end
+    end
+
+    context 'when calling a method that was not defined' do
+      it do
+        expect { configurable.configure { |c| c.nope '123456' } }
+          .to raise_error(NoMethodError)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -22,7 +22,6 @@ RSpec.configure do |config|
 
   config.order = 'random'
   config.include Sinclair::Matchers
-
-  config.before do
-  end
 end
+
+RSpec::Matchers.define_negated_matcher :not_change, :change

data/spec/support/models/dummy_config.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class DummyConfig
+end

data/spec/support/models/dummy_configurable.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class DummyConfigurable
+  extend Sinclair::Configurable
+
+  configurable_with :user, 'password'
+end

data/spec/support/models/my_config.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class MyConfig
+  attr_reader :name, :config
+end

data/spec/support/models/my_configurable.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class MyConfigurable
+  extend Sinclair::Configurable
+
+  configurable_with :host, :port
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinclair
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - DarthJee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-30 00:00:00.000000000 Z
+date: 2019-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -108,6 +108,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.30.0
+- !ruby/object:Gem::Dependency
+  name: rubycritic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.2
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -167,10 +181,15 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- config/rubycritc.rb
 - config/yardstick.rb
 - config/yardstick.yml
 - docker-compose.yml
 - lib/sinclair.rb
+- lib/sinclair/config.rb
+- lib/sinclair/config_builder.rb
+- lib/sinclair/config_factory.rb
+- lib/sinclair/configurable.rb
 - lib/sinclair/matchers.rb
 - lib/sinclair/matchers/add_method.rb
 - lib/sinclair/matchers/add_method_to.rb
@@ -178,6 +197,7 @@ files:
 - lib/sinclair/options_parser.rb
 - lib/sinclair/version.rb
 - scripts/check_readme.sh
+- scripts/rubycritic.sh
 - sinclair.gemspec
 - sinclair.jpg
 - spec/integration/readme/my_class_spec.rb
@@ -186,11 +206,17 @@ files:
 - spec/integration/readme/sinclair_spec.rb
 - spec/integration/sinclair/matchers_spec.rb
 - spec/integration/yard/my_builder_spec.rb
+- spec/integration/yard/sinclair/config_builder_spec.rb
+- spec/integration/yard/sinclair/config_factory_spec.rb
+- spec/integration/yard/sinclair/configurable_spec.rb
 - spec/integration/yard/sinclair/matchers/add_method_spec.rb
 - spec/integration/yard/sinclair/matchers/add_method_to_spec.rb
 - spec/integration/yard/sinclair/method_definition_spec.rb
 - spec/integration/yard/sinclair/options_parser_spec.rb
 - spec/integration/yard/sinclair_spec.rb
+- spec/lib/sinclair/config_builder_spec.rb
+- spec/lib/sinclair/config_factory_spec.rb
+- spec/lib/sinclair/configurable_spec.rb
 - spec/lib/sinclair/matchers/add_method_spec.rb
 - spec/lib/sinclair/matchers/add_method_to_spec.rb
 - spec/lib/sinclair/matchers_spec.rb
@@ -201,11 +227,15 @@ files:
 - spec/support/fixture_helpers.rb
 - spec/support/models/default_value.rb
 - spec/support/models/dummy_builder.rb
+- spec/support/models/dummy_config.rb
+- spec/support/models/dummy_configurable.rb
 - spec/support/models/dummy_options_parser.rb
 - spec/support/models/initial_valuer.rb
 - spec/support/models/my_builder.rb
 - spec/support/models/my_class.rb
 - spec/support/models/my_concern.rb
+- spec/support/models/my_config.rb
+- spec/support/models/my_configurable.rb
 - spec/support/models/my_model.rb
 - spec/support/models/person.rb
 - spec/support/models/purchase.rb