dry-configurable 0.6.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 51611822b7af9f064ab0b52e8708bf06351d1fba
-  data.tar.gz: ad9380c1994564966bd5caaa521026807b3a5a1a
+  metadata.gz: 24d1584b6f9d1d9fbe7fe62ef7b7c0afbd558176
+  data.tar.gz: b94c4d0b877b2093de30add176fc70e413c28ef0
 SHA512:
-  metadata.gz: 54182d4a1f47f5e2307cf1ee04edf5143495677767d731b23125a2c2a5fc5bff7d596736b0d238e6109b27cfa5510b525e0a7a4e10b2c30ab57f707af1cd2b92
-  data.tar.gz: 345a79f1ac2c33978fa8d608c96772e1cadf94083bc21bae654dc5e7c2004f7546f7d5c36ced4cd6ecccbf38722ba0592025aba64ede30c662d975a569277d1f
+  metadata.gz: 796c1b446cb4e31947f2274409325e4ec21ae2c8c8a34d5100723f74063c410756bd96a0327844f140a49bf0fd0e489194684c1876ed03c748e6e85a6c177c64
+  data.tar.gz: 44e36011d7d0c59f15d1dfb59b6e800c094be7a02ac60c781e8410f7ecfc151ed660ba4cec7928c6955f873ee215d7ef9ab2eb54d7ea237ca9e98027e1fff7ba

data/README.md

@@ -25,6 +25,12 @@ class App
   end
   # Defaults to nil if no default value is given
   setting :adapter
+  # Passing the reader option as true will create reader method for the class
+  setting :pool, 5, reader: true
+  # Passing the reader attributes works with nested configuration
+  setting :uploader, reader: true do
+    setting :bucket, 'dev'
+  end
 end
 
 App.configure do |config|
@@ -34,6 +40,8 @@ end
 App.config.database.dsn
 # => 'jdbc:sqlite:memory'
 App.config.adapter # => nil
+App.pool # => 5
+App.uploader.bucket # => 'dev'
 ```
 
 ## Links

data/lib/dry/configurable.rb

@@ -1,5 +1,8 @@
 require 'concurrent'
 require 'dry/configurable/config'
+require 'dry/configurable/error'
+require 'dry/configurable/nested_config'
+require 'dry/configurable/argument_parser'
 require 'dry/configurable/config/value'
 require 'dry/configurable/version'
 
@@ -32,6 +35,7 @@ module Dry
       base.class_eval do
         @_config_mutex = ::Mutex.new
         @_settings = ::Concurrent::Array.new
+        @_reader_attributes = ::Concurrent::Array.new
       end
     end
 
@@ -39,6 +43,7 @@ module Dry
     def inherited(subclass)
       subclass.instance_variable_set(:@_config_mutex, ::Mutex.new)
       subclass.instance_variable_set(:@_settings, @_settings.clone)
+      subclass.instance_variable_set(:@_reader_attributes, @_reader_attributes.clone)
       subclass.instance_variable_set(:@_config, @_config.clone) if defined?(@_config)
       super
     end
@@ -78,7 +83,9 @@ module Dry
     # @return [Dry::Configurable::Config]
     #
     # @api public
-    def setting(key, value = ::Dry::Configurable::Config::Value::NONE, &block)
+    def setting(key, *args, &block)
+      raise_already_defined_config(key) if defined?(@_config)
+      value, options = ArgumentParser.call(args)
       if block
         if block.parameters.empty?
           value = _config_for(&block)
@@ -89,9 +96,10 @@ module Dry
 
       _settings << ::Dry::Configurable::Config::Value.new(
         key,
-        value,
+        value || ::Dry::Configurable::Config::Value::NONE,
         processor || ::Dry::Configurable::Config::DEFAULT_PROCESSOR
       )
+      store_reader_options(key, options) if options.any?
     end
 
     # Return an array of setting names
@@ -108,20 +116,54 @@ module Dry
       @_settings
     end
 
+    def _reader_attributes
+      @_reader_attributes
+    end
+
     private
 
     # @private
     def _config_for(&block)
-      config_klass = ::Class.new { extend ::Dry::Configurable }
-      config_klass.instance_eval(&block)
-      config_klass.config
+      ::Dry::Configurable::NestedConfig.new(&block)
     end
 
     # @private
     def create_config
       @_config_mutex.synchronize do
+        create_config_for_nested_configurations
         @_config = ::Dry::Configurable::Config.create(_settings) unless _settings.empty?
       end
     end
+
+    # @private
+    def create_config_for_nested_configurations
+      nested_configs.map(&:create_config)
+    end
+
+    # @private
+    def nested_configs
+      _settings.select { |setting| setting.value.is_a?(::Dry::Configurable::NestedConfig) }.map(&:value)
+    end
+
+    # @private
+    def raise_already_defined_config(key)
+      raise AlreadyDefinedConfig,
+            "Cannot add setting +#{key}+, #{self} is already configured"
+    end
+
+    # @private
+    def store_reader_options(key, options)
+      _reader_attributes << key if options.fetch(:reader, false)
+    end
+
+    # @private
+    def method_missing(method, *args, &block)
+      _reader_attributes.include?(method) ? config.public_send(method, *args, &block) : super
+    end
+
+    # @private
+    def respond_to_missing?(method, _include_private = false)
+      _reader_attributes.include?(method) || super
+    end
   end
 end

data/lib/dry/configurable/argument_parser.rb

@@ -0,0 +1,91 @@
+module Dry
+  # Argument parser
+  #
+  # Passing and array or arguments, it will decide wich one are arguments
+  # and which one are options.
+  #
+  # We have a limitation if setting the value without options, as a hash
+  # having the same key as one of the valid options, will parse the value
+  # as options.
+  #
+  # @example
+  #   p = Dry::Configurable::ArgumentParser.new(['db:sqlite', { reader: true })
+  #
+  #   p.value # => 'db:sqlite'
+  #   p.options # => { reader: true }
+  #
+  #   Dry::Configurable::ArgumentParser.call(['db:sqlite', { reader: true })
+  #    # => [ 'db:sqlite', { reader: true } ]
+  module Configurable
+    # @private
+    class ArgumentParser
+      VALID_OPTIONS = %i(reader).freeze
+
+      def self.call(data)
+        parsed = new(data)
+        [parsed.value, parsed.options]
+      end
+
+      def initialize(data)
+        @data = data
+      end
+
+      def value
+        parse_args[:value]
+      end
+
+      def options
+        parse_args[:options]
+      end
+
+      private
+
+      attr_reader :data
+
+      # @private
+      def default_args
+        { value: nil, options: {} }
+      end
+
+      # @private
+      def parse_args
+        return default_args if data.empty?
+        if data.size > 1
+          { value: data.first, options: check_options(data.last) }
+        else
+          default_args.merge(check_for_value_or_options(data.first))
+        end
+      end
+
+      # @private
+      def check_options(opts)
+        return {} if opts.empty?
+        opts.select { |k, _| VALID_OPTIONS.include?(k) }
+      end
+
+      # @private
+      def check_for_value_or_options(args)
+        case args
+        when Hash
+          parse_hash(args)
+        else
+          { value: args }
+        end
+      end
+
+      # @private
+      def parse_hash(args)
+        if hash_include_options_key(args)
+          { options: check_options(args) }
+        else
+          { value: args }
+        end
+      end
+
+      # @private
+      def hash_include_options_key(hash)
+        hash.any? { |k, _| VALID_OPTIONS.include?(k) }
+      end
+    end
+  end
+end

data/lib/dry/configurable/config.rb

@@ -48,10 +48,10 @@ module Dry
         @config.each_with_object({}) do |tuple, hash|
           key, value = tuple
 
-          if value.kind_of?(::Dry::Configurable::Config)
+          if value.is_a?(::Dry::Configurable::Config)
             hash[key] = value.to_h
           else
-            hash[key] = value 
+            hash[key] = value
           end
         end
       end

data/lib/dry/configurable/config/value.rb

@@ -9,7 +9,9 @@ module Dry
         attr_reader :name, :processor
 
         def initialize(name, value, processor)
-          @name, @value, @processor = name.to_sym, value, processor
+          @name = name.to_sym
+          @value = value
+          @processor = processor
         end
 
         def value

data/lib/dry/configurable/error.rb

@@ -0,0 +1,8 @@
+# A collection of micro-libraries, each intended to encapsulate
+# a common task in Ruby
+module Dry
+  module Configurable
+    Error = Class.new(::StandardError)
+    AlreadyDefinedConfig = ::Class.new(Error)
+  end
+end

data/lib/dry/configurable/nested_config.rb

@@ -0,0 +1,33 @@
+module Dry
+  module Configurable
+    # @private
+    class NestedConfig
+      def initialize(&block)
+        klass = ::Class.new { extend ::Dry::Configurable }
+        klass.instance_eval(&block)
+        @klass = klass
+      end
+
+      # @private no, really...
+      def create_config
+        if @klass.instance_variables.include?(:@_config)
+          @klass.__send__(:create_config)
+        end
+      end
+
+      private
+
+      def config
+        @klass.config
+      end
+
+      def method_missing(method, *args, &block)
+        config.respond_to?(method) ? config.public_send(method, *args, &block) : super
+      end
+
+      def respond_to_missing?(method, _include_private = false)
+        config.respond_to?(method) || super
+      end
+    end
+  end
+end

data/lib/dry/configurable/version.rb

@@ -1,6 +1,6 @@
 module Dry
   module Configurable
     # @api public
-    VERSION = '0.6.0'.freeze
+    VERSION = '0.6.2'.freeze
   end
 end

data/spec/spec_helper.rb

@@ -43,7 +43,7 @@ RSpec.configure do |config|
   # Allows RSpec to persist some state between runs in order to support
   # the `--only-failures` and `--next-failure` CLI options. We recommend
   # you configure your source control system to ignore this file.
-  config.example_status_persistence_file_path = "spec/examples.txt"
+  config.example_status_persistence_file_path = 'spec/examples.txt'
 
   # Limits the available syntax to the non-monkey patched syntax that is
   # recommended. For more details, see:

data/spec/support/shared_examples/configurable.rb

@@ -50,6 +50,80 @@ RSpec.shared_examples 'a configurable class' do
           end
         end
 
+        context 'reader option' do
+          context 'without passing option' do
+            before do
+              klass.setting :dsn
+            end
+
+            before do
+              klass.configure do |config|
+                config.dsn = 'jdbc:sqlite:memory'
+              end
+            end
+
+            it 'will not create a getter method' do
+              expect(klass.respond_to?(:dsn)).to be_falsey
+            end
+          end
+
+          context 'with hash as value ' do
+            before do
+              klass.setting :dsn, { foo: 'bar' }, reader: true
+            end
+
+            it 'will create a getter method' do
+              expect(klass.dsn).to eq(foo: 'bar')
+              expect(klass.respond_to?(:dsn)).to be_truthy
+            end
+          end
+
+          context 'with option set to true' do
+            before do
+              klass.setting :dsn, 'testing', reader: true
+            end
+
+            it 'will create a getter method' do
+              expect(klass.dsn).to eq 'testing'
+              expect(klass.respond_to?(:dsn)).to be_truthy
+            end
+          end
+
+          context 'with nested configuration' do
+            before do
+              klass.setting :dsn, reader: true do
+                setting :pool, 5
+              end
+            end
+
+            it 'will create a nested getter method' do
+              expect(klass.dsn.pool).to eq 5
+            end
+          end
+
+          context 'with processor' do
+            context 'with default value' do
+              before do
+                klass.setting(:dsn, 'memory', reader: true) { |dsn| "sqlite:#{dsn}" }
+              end
+
+              it 'returns the default value' do
+                expect(klass.dsn).to eq('sqlite:memory')
+              end
+            end
+
+            context 'without default value' do
+              before do
+                klass.setting(:dsn, reader: true) { |dsn| "sqlite:#{dsn}" }
+              end
+
+              it 'returns the default value' do
+                expect(klass.dsn).to eq(nil)
+              end
+            end
+          end
+        end
+
         context 'nested configuration' do
           before do
             klass.setting :database do
@@ -118,7 +192,7 @@ RSpec.shared_examples 'a configurable class' do
 
         context 'with processor' do
           before do
-            klass.setting(:dsn, 'sqlite') { |dsn| "#{dsn}:memory"}
+            klass.setting(:dsn, 'sqlite') { |dsn| "#{dsn}:memory" }
           end
 
           before do
@@ -153,7 +227,7 @@ RSpec.shared_examples 'a configurable class' do
         context 'with processor' do
           before do
             klass.setting :database do
-              setting(:dsn, 'sqlite') { |dsn| "#{dsn}:memory"}
+              setting(:dsn, 'sqlite') { |dsn| "#{dsn}:memory" }
             end
 
             klass.configure do |config|
@@ -227,11 +301,10 @@ RSpec.shared_examples 'a configurable class' do
         context 'when the inherited settings are modified' do
           before do
             klass.setting :dsn
+            subclass.setting :db
             klass.configure do |config|
               config.dsn = 'jdbc:sqlite:memory'
             end
-
-            subclass.setting :db
           end
 
           subject!(:subclass) { Class.new(klass) }
@@ -249,9 +322,13 @@ RSpec.shared_examples 'a configurable class' do
       describe 'reset_config' do
         before do
           klass.setting :dsn, nil
+          klass.setting :pool do
+            setting :size, nil
+          end
 
           klass.configure do |config|
             config.dsn = 'sqlite:memory'
+            config.pool.size = 5
           end
 
           klass.reset_config
@@ -259,8 +336,22 @@ RSpec.shared_examples 'a configurable class' do
 
         it 'resets configuration to default values' do
           expect(klass.config.dsn).to be_nil
+          expect(klass.config.pool.size).to be_nil
         end
       end
     end
+
+    context 'Try to set new value after config has been created' do
+      before do
+        klass.setting :dsn, 'sqlite:memory'
+        klass.config
+      end
+
+      it 'raise an exception' do
+        expect { klass.setting :pool, 5 }.to raise_error(
+          Dry::Configurable::AlreadyDefinedConfig
+        )
+      end
+    end
   end
 end

data/spec/unit/dry/configurable/argument_parser_spec.rb

@@ -0,0 +1,114 @@
+RSpec.describe Dry::Configurable::ArgumentParser do
+  let(:klass) { Dry::Configurable::ArgumentParser }
+
+  context 'with no args' do
+    let(:parsed) { klass.new([]) }
+
+    it 'return default values' do
+      expect(parsed.value).to eq nil
+      expect(parsed.options).to eq({})
+    end
+  end
+
+  context 'with value and options' do
+    let(:parsed) { klass.new([value, options]) }
+
+    context 'valid options' do
+      let(:value) { 'dry-rb' }
+      let(:options) do
+        { reader: true }
+      end
+
+      it 'returns correct value and options' do
+        expect(parsed.value).to eq 'dry-rb'
+        expect(parsed.options).to eq(reader: true)
+      end
+    end
+
+    context 'invalid options' do
+      let(:value) { 'dry-rb' }
+      let(:options) do
+        { writer: true }
+      end
+
+      it 'returns correct values and empty options' do
+        expect(parsed.value).to eq 'dry-rb'
+        expect(parsed.options).to eq({})
+      end
+    end
+
+    context 'values as hash' do
+      let(:value) do
+        { db: 'dry-rb' }
+      end
+      let(:options) do
+        { reader: true }
+      end
+
+      it 'returns correct values and empty options' do
+        expect(parsed.value).to eq(db: 'dry-rb')
+        expect(parsed.options).to eq(reader: true)
+      end
+    end
+
+    context 'values as array' do
+      let(:value) { [1, 2, 3] }
+      let(:options) do
+        { reader: true }
+      end
+
+      it 'returns correct values and empty options' do
+        expect(parsed.value).to eq([1, 2, 3])
+        expect(parsed.options).to eq(reader: true)
+      end
+    end
+  end
+
+  context 'with value only' do
+    let(:parsed) { klass.new([value]) }
+    context 'valid options' do
+      let(:value) { 'dry-rb' }
+
+      it 'returns correct value and options' do
+        expect(parsed.value).to eq 'dry-rb'
+        expect(parsed.options).to eq({})
+      end
+    end
+
+    context 'with hash with non option key' do
+      let(:value) do
+        { writer: true }
+      end
+
+      it 'returns correct value and options' do
+        expect(parsed.value).to eq(writer: true)
+        expect(parsed.options).to eq({})
+      end
+    end
+
+    context 'with hash with option key' do
+      let(:value) do
+        { reader: true, writer: true }
+      end
+
+      it 'returns correct value and options' do
+        expect(parsed.value).to eq nil
+        expect(parsed.options).to eq(reader: true)
+      end
+    end
+  end
+
+  context 'with options only' do
+    let(:parsed) { klass.new([options]) }
+    context 'valid options' do
+      let(:options) do
+        { reader: true }
+      end
+
+      it 'returns correct value and options' do
+        expect(parsed.value).to eq nil
+        expect(parsed.options).to eq(reader: true)
+      end
+    end
+  end
+end

data/spec/unit/dry/configurable/config/value_spec.rb

@@ -3,7 +3,7 @@ RSpec.describe Dry::Configurable::Config::Value do
   let(:config) { klass.new(name, value, processor) }
   let(:name) { :db }
   let(:value) { 'test' }
-  let(:processor) { ->(v) { v }}
+  let(:processor) { ->(v) { v } }
 
   describe '#initialize' do
     it 'coerces string name to symbol' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-configurable
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.2
 platform: ruby
 authors:
 - Andy Holland
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-17 00:00:00.000000000 Z
+date: 2017-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -85,14 +85,18 @@ files:
 - dry-configurable.gemspec
 - lib/dry-configurable.rb
 - lib/dry/configurable.rb
+- lib/dry/configurable/argument_parser.rb
 - lib/dry/configurable/config.rb
 - lib/dry/configurable/config/value.rb
+- lib/dry/configurable/error.rb
+- lib/dry/configurable/nested_config.rb
 - lib/dry/configurable/test_interface.rb
 - lib/dry/configurable/version.rb
 - rakelib/rubocop.rake
 - spec/integration/configurable_spec.rb
 - spec/spec_helper.rb
 - spec/support/shared_examples/configurable.rb
+- spec/unit/dry/configurable/argument_parser_spec.rb
 - spec/unit/dry/configurable/config/value_spec.rb
 - spec/unit/dry/configurable/config_spec.rb
 homepage: https://github.com/dryrb/dry-configurable
@@ -115,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: A mixin to add configuration functionality to your classes
@@ -123,5 +127,6 @@ test_files:
 - spec/integration/configurable_spec.rb
 - spec/spec_helper.rb
 - spec/support/shared_examples/configurable.rb
+- spec/unit/dry/configurable/argument_parser_spec.rb
 - spec/unit/dry/configurable/config/value_spec.rb
 - spec/unit/dry/configurable/config_spec.rb