sinclair 1.3.4 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e1275a6e3f8459ed0176557d4d9580c7cac9bc537b36dd3a96179d43803035b
-  data.tar.gz: baba86f5fe29bddf70c3d440e0539c4d0aa4a7b892a9548f73dbaf8945d51be7
+  metadata.gz: 4826b55d94281092e5a0ba4d397366c39ec3494ec6f84743480c9e6ef69a030e
+  data.tar.gz: fbd63c4a98eacaf569a56c95411e71043f5b400bd7f98b593c73fba1a68d5bd6
 SHA512:
-  metadata.gz: ca4c580be409552638fb442d63b5036cac1d45134839f00551ea2cdcf1cada5f8736d6e1f2abdda97bd9d850a25d92599791efa15f423496796f30c834db053f
-  data.tar.gz: 604d5a4c072fff368b8bd6d062ab6730880bef1f29d6d197e00780cf7d8e98d3d6d64a34c87c8d93a1a367ec81a9a3ab98860111d5d425599d2777fb831db7dd
+  metadata.gz: 531c6f6db55bed97a3bfcf8f8c6001ae35cd5226aa5e386b0bb9442afcea7984bdf77ef4b16774e6e7c44c4b51c8ec15eac74431042f26a12d069909a2fa6a1f
+  data.tar.gz: 5820b843eaddf7838d430c4713645fbad5a8bf46850bc9cce5dbc1cc9f7d0005dc949969c06ba6ed3ca088a9790fdf32121e2e795dcc09935092636594809ed2

data/README.md

@@ -14,7 +14,7 @@ methods
 
 Yard Documentation
 -------------------
-https://www.rubydoc.info/gems/sinclair/1.3.4
+https://www.rubydoc.info/gems/sinclair/1.4.0
 
 Installation
 ---------------
@@ -335,7 +335,9 @@ the `configurable#configure` method
 Configurations can also be done through custom classes
 
 ```ruby
-  class MyServerConfig
+  class MyServerConfig < Sinclair::Config
+    config_attributes :host, :port
+
     def url
       if @port
         "http://#{@host}:#{@port}"
@@ -348,7 +350,7 @@ Configurations can also be done through custom classes
   class Client
     extend Sinclair::Configurable
 
-    configurable_by MyServerConfig, with: %i[host port]
+    configurable_by MyServerConfig
   end
 
   Client.configure do

data/WARNINGS.md

@@ -0,0 +1,69 @@
+# Warnings
+This documents tries to bring more information on warnings
+and depreations on current versions of the gem.
+
+## Usage of custom config classes
+Introduced: 1.3.0
+Changed in: 1.4.0
+
+In the past, you could use any custom configuration classes
+to configure your configurable. Those classes could be
+extended through the regular usage of ```.configurable_with```
+or have it's configuration attributes declared by
+```with``` option on ```configurable_with```
+
+```ruby
+class MyConfig
+  def url
+    if @port
+      "http://#{@host}:#{@port}"
+    else
+      "http://#{@host}"
+    end
+  end
+end
+
+class MyClient
+  configutable_by MyConfig, with: [:host, :port]
+  configurable_with timeout: 5.seconds
+end
+
+MyClient.configure do
+  port 5555
+  host 'myhost.com'
+  timeout 10.seconds
+end
+```
+
+Now, the configuration class should extend ```Sinclair::ConfigClass```
+and the attributes defined within the class itself, still
+being able to extend it through the usage of
+```.configurable_with``` call after ```configurable_by```
+
+```ruby
+class MyConfig
+  extend Sinclair::ConfigClass
+
+  config_attributes :host, :port
+
+  def url
+    if @port
+      "http://#{@host}:#{@port}"
+    else
+      "http://#{@host}"
+    end
+  end
+end
+
+class MyClient
+  configutable_by MyConfig
+
+  configurable_with timeout: 5.seconds
+end
+
+MyClient.configure do
+  port 5555
+  host 'myhost.com'
+  timeout 10.seconds
+end
+```

data/config/yardstick.yml

@@ -37,8 +37,8 @@ rules:
       - Sinclair::ConfigFactory#initialize
       - Sinclair::ConfigFactory#config_class
       - Sinclair::ConfigFactory#config_attributes
-      - Sinclair::ConfigFactory::MethodsBuilder#names
-      - Sinclair::ConfigFactory::MethodsBuilder#defaults
+      - Sinclair::Config::MethodsBuilder#names
+      - Sinclair::Config::MethodsBuilder#defaults
       - Sinclair::Configurable#config
       - Sinclair::Configurable#reset_config
       - Sinclair::Configurable#configure
@@ -60,9 +60,9 @@ rules:
       - Sinclair::ConfigFactory#initialize
       - Sinclair::ConfigFactory#config_class
       - Sinclair::ConfigFactory#config_attributes
-      - Sinclair::ConfigFactory::MethodsBuilder#initialize
-      - Sinclair::ConfigFactory::MethodsBuilder#names
-      - Sinclair::ConfigFactory::MethodsBuilder#defaults
+      - Sinclair::Config::MethodsBuilder#initialize
+      - Sinclair::Config::MethodsBuilder#names
+      - Sinclair::Config::MethodsBuilder#defaults
   Summary::Length:
     enabled: true
     exclude: []

data/lib/sinclair.rb

@@ -86,6 +86,7 @@ class Sinclair
   autoload :MethodDefinition, 'sinclair/method_definition'
   autoload :Config,           'sinclair/config'
   autoload :ConfigBuilder,    'sinclair/config_builder'
+  autoload :ConfigClass,      'sinclair/config_class'
   autoload :ConfigFactory,    'sinclair/config_factory'
   autoload :Configurable,     'sinclair/configurable'
 

data/lib/sinclair/config.rb

@@ -7,5 +7,32 @@ class Sinclair
   #
   # The instance variables will be set by {ConfigBuilder}
   class Config
+    autoload :MethodsBuilder, 'sinclair/config/methods_builder'
+    extend ConfigClass
+
+    # Return all the current configurations in a hash
+    #
+    # @return [Hash]
+    #
+    # @example Checking all hash/json formats
+    #   class LoginConfig < Sinclair::Config
+    #     add_configs :password, username: 'bob'
+    #   end
+    #
+    #   config = LoginConfig.new
+    #
+    #   config.to_hash
+    #   # returns { 'password' => nil, 'username' => 'bob' }
+    #
+    #   config.as_json
+    #   # returns { 'password' => nil, 'username' => 'bob' }
+    #
+    #   config.to_json
+    #   # returns '{"password":null,"username":"bob"}'
+    def to_hash
+      self.class.config_attributes.each_with_object({}) do |attribute, hash|
+        hash[attribute.to_s] = public_send(attribute)
+      end
+    end
   end
 end

data/lib/sinclair/{config_factory → config}/methods_builder.rb

@@ -1,19 +1,34 @@
 # frozen_string_literal: true
 
 class Sinclair
-  class ConfigFactory
+  class Config
     # @api private
     #
     # Class responsible for adding method to configuration
     # classes
     class MethodsBuilder < Sinclair
+      # Instantiate method builder and build the methods
+      #
+      # @param (see #initialize)
+      #
+      # @overload build(klass, *names, default)
+      #   @param names [Array<Symbol,String>] List of configuration names
+      #     to be added
+      #   @param default [Hash] Configurations that will receive a default
+      #     value when not configured
+      #
+      # @return [MethodsBuilder]
+      def self.build(klass, *names)
+        new(klass, *names).tap(&:build)
+      end
+
       # @param klass [Class] class inheriting from {Sinclair::Config}
       #  that will receive the methods
       # @overload initialize(klass, *names, default)
       #   @param names [Array<Symbol,String>] List of configuration names
-      #   to be added
+      #     to be added
       #   @param default [Hash] Configurations that will receive a default
-      #   value when not configured
+      #     value when not configured
       def initialize(klass, *names)
         super(klass)
 

data/lib/sinclair/config_builder.rb

@@ -7,6 +7,8 @@ class Sinclair
   #
   # @example
   #   class MyConfig
+  #     extend Sinclair::ConfigClass
+  #
   #     attr_reader :name, :config
   #   end
   #
@@ -47,7 +49,7 @@ class Sinclair
     #
     # @return [Object]
     def method_missing(method_name, *args)
-      return super unless @config_attributes.include?(method_name)
+      return super unless method_included?(method_name)
 
       @config.instance_variable_set("@#{method_name}", *args)
     end
@@ -60,7 +62,21 @@ class Sinclair
     #
     # @see #method_missing
     def respond_to_missing?(method_name, include_private)
-      @config_attributes.include?(method_name) || super
+      method_included?(method_name) || super
+    end
+
+    # Checks if a method is included in the methods defined
+    #
+    # @param method_name [Symbol] name of the method called
+    #
+    # @return [TrueClass,FalseClass]
+    #
+    # @todo get rid of @config_attributes when only
+    #   Sinclair::ConfigClass are accepted
+    def method_included?(method_name)
+      @config_attributes.include?(method_name) ||
+        @config.class.is_a?(Sinclair::ConfigClass) &&
+          @config.class.config_attributes.include?(method_name)
     end
   end
 end

data/lib/sinclair/config_class.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+class Sinclair
+  # @api public
+  #
+  # Module with all class methods for {Config}
+  #
+  # Any class that will be used as configuration class
+  # should extend {ConfigClass} as {#config_attributes}
+  # is used to check what configurations have been added
+  #
+  # @example (see #add_configs)
+  module ConfigClass
+    # @api private
+    #
+    # Adds an attribute to the list of attributes
+    #
+    # The list of attributes represent attribute
+    # readers that class instances can respond to
+    #
+    # Subclasses will respond to the same attributes as the
+    # parent class plus it's own
+    #
+    # This method does not add the method or .attr_reader
+    #
+    # @param attributes [Array<Symbol,String>] list of
+    #   attributes the instances should respond to
+    #
+    # @return [Array<Symbol>] all attributes the class have
+    #
+    # @see #attributes
+    def config_attributes(*attributes)
+      @config_attributes ||= []
+
+      if attributes.present?
+        new_attributes = attributes.map(&:to_sym) - @config_attributes
+        @config_attributes.concat(new_attributes)
+      end
+
+      if superclass.is_a?(ConfigClass)
+        (superclass.config_attributes.dup + @config_attributes).uniq
+      else
+        @config_attributes
+      end
+    end
+
+    # Add a config attribute
+    #
+    # This method adds an attribute (see {#config_attributes})
+    # and the method readers
+    #
+    # @overload add_configs(*names, default)
+    #   @param names [Array<Symbol,String>] List of configuration names
+    #     to be added
+    #   @param default [Hash] Configurations that will receive a default
+    #     value when not configured
+    #
+    # @return [MethodsBuilder]
+    #
+    # @see MethodsBuilder#build
+    #
+    # @example Adding configurations to config class
+    #   class AppConfig
+    #     extend Sinclair::ConfigClass
+    #
+    #     add_configs :secret, app_name: 'MyApp'
+    #   end
+    #
+    #   config = AppConfig.new
+    #
+    #   config.secret
+    #   # return nil
+    #
+    #   config.app_name
+    #   # return 'MyApp'
+    #
+    #   config_builder = Sinclair::ConfigBuilder.new(config)
+    #
+    #   config_builder.secret '123abc'
+    #   config_builder.app_name 'MySuperApp'
+    #
+    #   config.secret
+    #   # return '123abc'
+    #
+    #   config.app_name
+    #   # return 'MySuperApp'
+    def add_configs(*args)
+      Config::MethodsBuilder.new(self, *args).tap do |builder|
+        builder.build
+
+        config_attributes(*builder.config_names)
+      end
+    end
+  end
+end

data/lib/sinclair/config_factory.rb

@@ -16,13 +16,20 @@ class Sinclair
   #   factory.config.equal?(config) # returns true
   #   config.name                   # returns 'John'
   class ConfigFactory
-    autoload :MethodsBuilder, 'sinclair/config_factory/methods_builder'
-
+    # @api private
+    # Deprecation warning message
+    # @see https://github.com/darthjee/sinclair/blob/master/WARNINGS.md#usage-of-custom-config-classes
+    CONFIG_CLASS_WARNING = 'Config class is expected to be ConfigClass. ' \
+      "In future releases this will be enforced.\n" \
+      'see more on https://github.com/darthjee/sinclair/blob/master/WARNINGS.md#usage-of-custom-config-classes'
     # @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
+
+      return if config_class.is_a?(ConfigClass)
+      warn CONFIG_CLASS_WARNING
     end
 
     # @api public
@@ -71,6 +78,8 @@ class Sinclair
     #   {ConfigBuilder} is able to set those values when invoked
     #
     # @return [Array<Symbol>] all known config attributes
+    # @todo remove class check once only
+    #   ConfigClass are accepted
     #
     # @example Adding configuration name
     #   factory = Sinclair::ConfigFactory.new
@@ -84,9 +93,11 @@ class Sinclair
     #   config.respond_to? :active
     #   # returns true
     def add_configs(*args)
-      builder = MethodsBuilder.new(config_class, *args)
-
-      builder.build
+      builder = if config_class.is_a?(Sinclair::ConfigClass)
+                  config_class.add_configs(*args)
+                else
+                  Config::MethodsBuilder.build(config_class, *args)
+                end
 
       config_attributes.concat(builder.config_names.map(&:to_sym))
     end
@@ -107,6 +118,8 @@ class Sinclair
     #
     # @example Setting name on config
     #   class MyConfig
+    #     extend Sinclair::ConfigClass
+    #
     #     attr_reader :name
     #   end
     #

data/lib/sinclair/configurable.rb

@@ -17,6 +17,14 @@ class Sinclair
   # @example (see #configurable_with)
   # @example (see #configurable_by)
   module Configurable
+    # @api private
+    # Deprecation warning message
+    # @see https://github.com/darthjee/sinclair/blob/master/WARNINGS.md#usage-of-custom-config-classes
+    CONFIG_CLASS_WARNING = 'Config classes attributes should ' \
+      'be defined inside the class or through the usage of ' \
+      "configurable_with.\n" \
+      "In future releases this will be enforced.\n" \
+      'see more on https://github.com/darthjee/sinclair/blob/master/WARNINGS.md#usage-of-custom-config-classes'
     # (see ConfigFactory#config)
     # @see ConfigFactory#config
     def config
@@ -116,7 +124,9 @@ class Sinclair
     # @return [ConfigFactory]
     #
     # @example Configured by custom config class
-    #   class MyServerConfig
+    #   class MyServerConfig < Sinclair::Config
+    #     config_attributes :host, :port
+    #
     #     def url
     #       if @port
     #         "http://#{@host}:#{@port}"
@@ -129,7 +139,7 @@ class Sinclair
     #   class Client
     #     extend Sinclair::Configurable
     #
-    #     configurable_by MyServerConfig, with: %i[host port]
+    #     configurable_by MyServerConfig
     #   end
     #
     #   Client.configure do
@@ -144,6 +154,8 @@ class Sinclair
     #
     #   Client.config.url # returns 'http://interstella.com:8080'
     def configurable_by(config_class, with: [])
+      warn CONFIG_CLASS_WARNING if with.present?
+
       @config_factory = ConfigFactory.new(
         config_class: config_class,
         config_attributes: with.map(&:to_sym)

data/lib/sinclair/version.rb

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

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'spec_helper'
+
 describe Sinclair::ConfigBuilder do
   describe 'yard' do
     describe '#instance_eval' do

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::ConfigClass do
+  describe 'yard' do
+    describe '.add_configs' do
+      subject(:config) { AppConfig.new }
+
+      it 'has a secret configuration method' do
+        expect(config.secret).to be_nil
+      end
+
+      it 'has a app_name configuration method' do
+        expect(config.app_name).to eq('MyApp')
+      end
+
+      context 'when configured' do
+        let(:config_builder) do
+          Sinclair::ConfigBuilder.new(config)
+        end
+
+        before do
+          config_builder.secret '123abc'
+          config_builder.app_name 'MySuperApp'
+        end
+
+        it 'has a secret configuration method' do
+          expect(config.secret).to eq('123abc')
+        end
+
+        it 'has a app_name configuration method' do
+          expect(config.app_name).to eq('MySuperApp')
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'spec_helper'
+
 describe Sinclair::ConfigFactory do
   describe '#yard' do
     subject(:factory) do

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Config do
+  describe 'yard' do
+    describe '#to_hash' do
+      subject(:config) { config_class.new }
+
+      let(:config_class) { LoginConfig }
+
+      it 'returns all configs hash' do
+        expect(config.to_hash)
+          .to eq('password' => nil, 'username' => 'bob')
+      end
+
+      it 'returns all configs hash on as_json calls' do
+        expect(config.as_json)
+          .to eq('password' => nil, 'username' => 'bob')
+      end
+
+      it 'returns all configs json on to_json calls' do
+        expect(config.to_json)
+          .to eq('{"password":null,"username":"bob"}')
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'spec_helper'
+
 describe Sinclair::MethodDefinition do
   describe 'yard' do
     describe '#build' do

data/spec/lib/sinclair/{config_factory → config}/methods_builder_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Sinclair::ConfigFactory::MethodsBuilder do
+describe Sinclair::Config::MethodsBuilder do
   describe '#build' do
     let(:config_class) { Class.new(Sinclair::Config) }
     let(:config)       { config_class.new }

data/spec/lib/sinclair/config_builder_spec.rb

@@ -1,51 +1,88 @@
 # frozen_string_literal: true
 
+require 'spec_helper'
+
 describe Sinclair::ConfigBuilder do
   subject(:builder) { described_class.new(config, *config_attributes) }
 
-  let(:config)            { MyConfig.new }
+  let(:config_class)      { MyConfig }
+  let(:config)            { config_class.new }
   let(:config_attributes) { [:name] }
 
-  it 'changes responds to given config' do
-    expect(builder).to respond_to(:name)
-  end
+  describe '#responds_to' do
+    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 'does not respond to other 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
+    it 'responds to other parent methods' do
+      expect(builder).to respond_to(:to_s)
+    end
+
+    context 'when it was instatiated without the attribute' do
+      let(:config_attributes) { [] }
+
+      it 'does not respond to given attribute' do
+        expect(builder).not_to respond_to(:name)
+      end
 
-  context 'when builder was configuratd with the method called' do
-    let(:config_attributes) { [:name] }
+      context 'when class is a ConfigClass and has been configured' do
+        let(:config_class) { Class.new(Sinclair::Config) }
 
-    it 'sets the instance variable' do
-      expect { builder.name 'John' }
-        .to change(config, :name)
-        .from(nil).to('John')
+        before { config_class.config_attributes(:name) }
+
+        it 'changes responds to given config' do
+          expect(builder).to respond_to(:name)
+        end
+      end
     end
   end
 
-  context 'when builder was configuratd without the method called' do
-    let(:config_attributes) { [] }
+  describe '#method_missing' do
+    context 'when builder was configuratd with the method called' do
+      let(:config_attributes) { [:name] }
 
-    it 'does not set the instance variable and raises error' do
-      expect { builder.name 'John' }
-        .to raise_error(NoMethodError)
-        .and not_change(config, :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
+
+      context 'with config class that has been configured with it' do
+        let(:config_class) { Class.new(Sinclair::Config) }
+
+        before { config_class.add_configs(:name) }
+
+        it 'sets the instance variable' do
+          expect { builder.name 'John' }
+            .to change(config, :name)
+            .from(nil).to('John')
+        end
+      end
     end
-  end
 
-  context 'when using a variable name from builder variables' do
-    let(:config_attributes) { [:config] }
+    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')
+      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
 end

data/spec/lib/sinclair/config_class_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::ConfigClass do
+  subject(:klass) do
+    Class.new { extend Sinclair::ConfigClass }
+  end
+
+  let(:child_klass) { Class.new(klass) }
+
+  let(:config)      { klass.new }
+
+  describe '.config_attributes' do
+    it_behaves_like 'a config class with .config_attributes method'
+  end
+
+  describe '.add_configs' do
+    let(:setter_block) do
+      proc { |value| config.instance_variable_set(:@name, value) }
+    end
+
+    it_behaves_like 'a config methods builder adding config' do
+      let(:code_block) { proc { klass.add_configs(:name) } }
+
+      it 'sets nil value by default' do
+        code_block.call
+        expect(config.name).to be_nil
+      end
+
+      it 'adds attributes to class' do
+        expect(&code_block).to change(klass, :config_attributes)
+          .from([]).to(%i[name])
+      end
+    end
+
+    context 'when giving defaults' do
+      it_behaves_like 'a config methods builder adding config' do
+        let(:code_block) { proc { klass.add_configs(name: 'Bob') } }
+
+        it 'sets default value' do
+          code_block.call
+          expect(config.name).to eq('Bob')
+        end
+
+        it 'adds attributes to class' do
+          expect(&code_block).to change(klass, :config_attributes)
+            .from([]).to(%i[name])
+        end
+      end
+    end
+  end
+end

data/spec/lib/sinclair/config_factory_spec.rb

@@ -28,13 +28,43 @@ describe Sinclair::ConfigFactory do
       end
     end
 
-    context 'when initializing with custom config class' do
+    context 'when initializing with custom config class that extends config_class' do
+      subject(:factory) { described_class.new(config_class: MyConfig) }
+
+      it do
+        expect(factory.config).to be_a(MyConfig)
+      end
+
+      context 'when calling after reset_config' do
+        before { factory.reset_config }
+
+        it do
+          expect(factory.config).to be_a(MyConfig)
+        end
+      end
+    end
+
+    context 'when initializing with custom config class that does not extend config_class' do
       subject(:factory) { described_class.new(config_class: DummyConfig) }
 
+      # rubocop:disable RSpec/AnyInstance
+      before do
+        allow_any_instance_of(described_class)
+          .to receive(:warn)
+      end
+      # rubocop:enable RSpec/AnyInstance
+
       it do
         expect(factory.config).to be_a(DummyConfig)
       end
 
+      it 'warns about class use' do
+        factory.config
+
+        expect(factory).to have_received(:warn)
+          .with described_class::CONFIG_CLASS_WARNING
+      end
+
       context 'when calling after reset_config' do
         before { factory.reset_config }
 
@@ -60,7 +90,7 @@ describe Sinclair::ConfigFactory do
     end
 
     context 'when initializing with custom config class' do
-      subject(:factory) { described_class.new(config_class: DummyConfig) }
+      subject(:factory) { described_class.new(config_class: MyConfig) }
 
       it 'reset_configs instance' do
         expect { factory.reset_config }
@@ -119,6 +149,55 @@ describe Sinclair::ConfigFactory do
         end
       end
     end
+
+    context 'when config class was set from common class' do
+      subject(:factory) { described_class.new(config_class: config_class) }
+
+      let(:config_class) { Class.new }
+
+      # rubocop:disable RSpec/AnyInstance
+      before do
+        allow_any_instance_of(described_class)
+          .to receive(:warn)
+      end
+      # rubocop:enable RSpec/AnyInstance
+
+      it_behaves_like 'a config factory adding config' do
+        let(:method_call) { proc { add_configs(:name) } }
+
+        it 'does not set a default value' do
+          code_block.call
+
+          expect(factory.config.name).to be_nil
+        end
+
+        it 'warns about class use' do
+          code_block.call
+
+          expect(factory).to have_received(:warn)
+            .with described_class::CONFIG_CLASS_WARNING
+        end
+      end
+
+      context 'when passing a hash' do
+        it_behaves_like 'a config factory adding config' do
+          let(:method_call) { proc { add_configs(name: 'Bobby') } }
+
+          it 'sets a default value' do
+            code_block.call
+
+            expect(factory.config.name).to eq('Bobby')
+          end
+
+          it 'warns about class use' do
+            code_block.call
+
+            expect(factory).to have_received(:warn)
+              .with described_class::CONFIG_CLASS_WARNING
+          end
+        end
+      end
+    end
   end
 
   describe '#configure' do

data/spec/lib/sinclair/config_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Config do
+  subject(:config) { klass.new }
+
+  let(:child_klass) { Class.new(klass) }
+
+  let(:klass) { Class.new(described_class) }
+
+  describe '.config_attributes' do
+    it_behaves_like 'a config class with .config_attributes method'
+  end
+
+  describe '#to_hash' do
+    it 'returns empty hash' do
+      expect(config.as_json).to eq({})
+    end
+
+    context 'when attributes have been defined' do
+      before do
+        klass.config_attributes(:username, :password)
+        klass.attr_reader(:username, :password)
+      end
+
+      it 'uses given attributes to create json' do
+        expect(config.as_json)
+          .to eq('username' => nil, 'password' => nil)
+      end
+
+      context 'when the method called sets instance variable' do
+        before do
+          klass.add_configs(name: 'John')
+        end
+
+        it 'returns the value' do
+          expect(config.as_json).to eq(
+            'name' => 'John', 'username' => nil, 'password' => nil
+          )
+        end
+      end
+    end
+
+    context 'when passing options' do
+      before do
+        klass.add_configs(username: 'john', password: '123456')
+      end
+
+      it 'accpes only option' do
+        expect(config.as_json(only: 'username'))
+          .to eq('username' => 'john')
+      end
+
+      it 'accepts except options' do
+        expect(config.as_json(except: 'password'))
+          .to eq('username' => 'john')
+      end
+    end
+  end
+
+  describe '#to_json' do
+    it 'returns empty json' do
+      expect(config.to_json).to eq('{}')
+    end
+
+    context 'when attributes have been defined' do
+      before do
+        klass.config_attributes(:username, :password)
+        klass.attr_reader(:username, :password)
+      end
+
+      it 'uses given attributes to create json' do
+        expect(config.to_json)
+          .to eq('{"username":null,"password":null}')
+      end
+
+      context 'when the method called sets instance variable' do
+        before do
+          klass.add_configs(name: 'John')
+        end
+
+        it 'returns the value' do
+          expect(config.to_json).to eq(
+            '{"username":null,"password":null,"name":"John"}'
+          )
+        end
+      end
+    end
+
+    context 'when passing options' do
+      before do
+        klass.add_configs(username: 'john', password: '123456')
+      end
+
+      it 'accpes only option' do
+        expect(config.to_json(only: 'username'))
+          .to eq('{"username":"john"}')
+      end
+
+      it 'accepts except options' do
+        expect(config.to_json(except: 'password'))
+          .to eq('{"username":"john"}')
+      end
+    end
+  end
+end

data/spec/lib/sinclair/configurable_spec.rb

@@ -123,6 +123,14 @@ describe Sinclair::Configurable do
         end
       end
 
+      before do
+        # rubocop:disable RSpec/SubjectStub
+        allow(configurable)
+          .to receive(:warn)
+          .with(described_class::CONFIG_CLASS_WARNING)
+        # rubocop:enable RSpec/SubjectStub
+      end
+
       it 'does not add symbol methods config object' do
         expect(&block)
           .not_to add_method(:host).to(configurable.config)
@@ -133,6 +141,11 @@ describe Sinclair::Configurable do
           .not_to add_method(:port).to(configurable.config)
       end
 
+      it 'sends deprecation warning' do
+        block.call
+        expect(configurable).to have_received(:warn)
+      end
+
       it 'does not raises error on configuration of given symbol attributes' do
         block.call
 
@@ -177,6 +190,11 @@ describe Sinclair::Configurable do
       let(:config_class) { ServerConfig }
 
       before do
+        # rubocop:disable RSpec/SubjectStub
+        allow(configurable)
+          .to receive(:warn)
+          .with(described_class::CONFIG_CLASS_WARNING)
+        # rubocop:enable RSpec/SubjectStub
         configurable.send(
           :configurable_by, config_class, with: [:host, 'port']
         )

data/spec/support/models/app_config.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AppConfig
+  extend Sinclair::ConfigClass
+
+  add_configs :secret, app_name: 'MyApp'
+end

data/spec/support/models/client.rb

@@ -5,5 +5,5 @@ require './spec/support/models/my_server_config'
 class Client
   extend Sinclair::Configurable
 
-  configurable_by MyServerConfig, with: %i[host port]
+  configurable_by MyServerConfig
 end

data/spec/support/models/login_config.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class LoginConfig < Sinclair::Config
+  add_configs :password, username: 'bob'
+end

data/spec/support/models/my_config.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
 class MyConfig
+  extend Sinclair::ConfigClass
+
   attr_reader :name, :config
 end

data/spec/support/models/my_server_config.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-class MyServerConfig
+class MyServerConfig < Sinclair::Config
+  config_attributes :host, :port
+
   def url
     if @port
       "http://#{@host}:#{@port}"

data/spec/support/models/server_config.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-class ServerConfig
+class ServerConfig < Sinclair::Config
   attr_reader :host, :port
 end

data/spec/support/shared_examples/config.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+shared_examples 'a config class with .config_attributes method' do
+  let(:attributes) { [:username, 'password', :key] }
+
+  describe 'setting the attributes' do
+    it 'adds symbol attributes to class attributes' do
+      expect { klass.config_attributes(*attributes) }
+        .to change(klass, :config_attributes)
+        .from([]).to(%i[username password key])
+    end
+
+    context 'when class already has attributes' do
+      before do
+        klass.config_attributes('email')
+      end
+
+      it 'adds new attributes' do
+        expect { klass.config_attributes(*attributes) }
+          .to change(klass, :config_attributes)
+          .from([:email]).to(%i[email username password key])
+      end
+    end
+
+    context 'when attributes have already been added' do
+      before do
+        klass.config_attributes('username', :password)
+      end
+
+      it 'adds new attributes' do
+        expect { klass.config_attributes(*attributes) }
+          .to change(klass, :config_attributes)
+          .from(%i[username password])
+          .to(%i[username password key])
+      end
+    end
+
+    context 'when there is a child class' do
+      it 'adds attributes to child class' do
+        expect { klass.config_attributes(*attributes) }
+          .to change(child_klass, :config_attributes)
+          .from([]).to(%i[username password key])
+      end
+
+      context 'when child class already has attributes' do
+        before do
+          child_klass.config_attributes('email')
+        end
+
+        it 'adds new attributes to child class' do
+          expect { klass.config_attributes(*attributes) }
+            .to change(child_klass, :config_attributes)
+            .from([:email]).to(%i[username password key email])
+        end
+      end
+
+      context 'when child class already has one of the attributes' do
+        before do
+          child_klass.config_attributes(:email, 'username')
+        end
+
+        it 'adds new attributes to child class' do
+          expect { klass.config_attributes(*attributes) }
+            .to change(child_klass, :config_attributes)
+            .from(%i[email username]).to(%i[username password key email])
+        end
+      end
+    end
+
+    context 'when there is a parent class' do
+      it 'does not add attributes to parent class' do
+        expect { child_klass.config_attributes(*attributes) }
+          .not_to change(klass, :config_attributes)
+      end
+
+      context 'when parent already has attributes' do
+        before do
+          klass.config_attributes(:email, 'username')
+        end
+
+        it 'adds only attributes that had not been defined before' do
+          expect { child_klass.config_attributes(*attributes) }
+            .to change(child_klass, :config_attributes)
+            .from(%i[email username]).to(%i[email username password key])
+        end
+      end
+    end
+  end
+
+  describe 'retrieving the attributes' do
+    let(:attributes) { [:username, 'password', :key] }
+
+    context 'when attributes have been added' do
+      before { klass.config_attributes(*attributes) }
+
+      it 'returns added attributes' do
+        expect(klass.config_attributes).to eq(%i[username password key])
+      end
+    end
+
+    context 'when parent class has attributes' do
+      before { klass.config_attributes(*attributes) }
+
+      it 'returns parents attributes also' do
+        expect(child_klass.config_attributes).to eq(%i[username password key])
+      end
+    end
+
+    context 'when parent class changes its attributes' do
+      it 'returns adds new attributes to self' do
+        expect { klass.config_attributes(*attributes) }
+          .to change(child_klass, :config_attributes)
+          .from([]).to(%i[username password key])
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinclair
 version: !ruby/object:Gem::Version
-  version: 1.3.4
+  version: 1.4.0
 platform: ruby
 authors:
 - DarthJee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-21 00:00:00.000000000 Z
+date: 2019-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -181,15 +181,17 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- WARNINGS.md
 - config/rubycritc.rb
 - config/yardstick.rb
 - config/yardstick.yml
 - docker-compose.yml
 - lib/sinclair.rb
 - lib/sinclair/config.rb
+- lib/sinclair/config/methods_builder.rb
 - lib/sinclair/config_builder.rb
+- lib/sinclair/config_class.rb
 - lib/sinclair/config_factory.rb
-- lib/sinclair/config_factory/methods_builder.rb
 - lib/sinclair/configurable.rb
 - lib/sinclair/matchers.rb
 - lib/sinclair/matchers/add_method.rb
@@ -211,7 +213,9 @@ files:
 - 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_class_spec.rb
 - spec/integration/yard/sinclair/config_factory_spec.rb
+- spec/integration/yard/sinclair/config_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
@@ -220,9 +224,11 @@ files:
 - 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/methods_builder_spec.rb
 - spec/lib/sinclair/config_builder_spec.rb
-- spec/lib/sinclair/config_factory/methods_builder_spec.rb
+- spec/lib/sinclair/config_class_spec.rb
 - spec/lib/sinclair/config_factory_spec.rb
+- spec/lib/sinclair/config_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
@@ -234,6 +240,7 @@ files:
 - spec/lib/sinclair_spec.rb
 - spec/spec_helper.rb
 - spec/support/fixture_helpers.rb
+- spec/support/models/app_config.rb
 - spec/support/models/client.rb
 - spec/support/models/default_value.rb
 - spec/support/models/default_value_builder.rb
@@ -245,6 +252,7 @@ files:
 - spec/support/models/http_json_model.rb
 - spec/support/models/http_person.rb
 - spec/support/models/initial_valuer.rb
+- spec/support/models/login_config.rb
 - spec/support/models/my_builder.rb
 - spec/support/models/my_class.rb
 - spec/support/models/my_concern.rb
@@ -257,6 +265,7 @@ files:
 - spec/support/models/server.rb
 - spec/support/models/server_config.rb
 - spec/support/models/validator_builder.rb
+- spec/support/shared_examples/config.rb
 - spec/support/shared_examples/config_factory.rb
 - spec/support/shared_examples/method_definition.rb
 homepage: https://github.com/darthjee/sinclair