dry-configurable 0.1.7 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 58a630055aefd53b2ec5d0261f353e9779dcab8f
-  data.tar.gz: 42b5d3dddc4d819a6e80adcd3d9b341fed1cbea0
+  metadata.gz: eeb18b428640615a653b1e669bcbedf1130f83ef
+  data.tar.gz: 294ec402fe8dbfb378c6a5e1d5d442c49ac7baf1
 SHA512:
-  metadata.gz: d13cd68936ab7a5f96ed705011b1bd5cfb8112091a825fa2fb38e3afe4fdfd72be2f2646504dd00c543bc95ef310e1bb67b1a3d129c683a0d73b63ab3d31a0f0
-  data.tar.gz: 5ac518f3fc7f260431a9b5122045c6a53b32929529c2384618ef870fc2da399e9ffa4cc66d20239258a7422c14501b16431fcbe0aac26e9bba940bd0bf63d77f
+  metadata.gz: f3c268381efd9f202447a9785873ea151e5ce4edc004c87006a0c5b91165b3b29827d99799cf2f75a386214c5906b09d9b12983aec05502ad88591f1fa702896
+  data.tar.gz: fd8c289e25a8fa28ec55e1f69ec5f569e2b6dbf0506ca7df49a80c6277c99510bc0505dc7c063fd97144f2723105bba62448472bc2db73c941dce1bca8db9cbf

data/.gitignore

@@ -6,3 +6,4 @@ bin/
 tmp/
 .idea/
 Gemfile.lock
+spec/examples.txt

data/.rspec

@@ -1,3 +1,2 @@
 --color
---require spec_helper
---order random
+--require ./spec/spec_helper.rb

data/.travis.yml

@@ -1,20 +1,25 @@
 language: ruby
-sudo: false
+dist: trusty
+sudo: required
 cache: bundler
 bundler_args: --without console
 script:
   - bundle exec rake spec
+after_success:
+  - '[ -d coverage ] && bundle exec codeclimate-test-reporter'
 rvm:
   - 2.0
   - 2.1
   - 2.2
-  - rbx-2
-  - jruby
+  - 2.3.1
+  - rbx-3
+  - jruby-9.1.5.0
   - ruby-head
   - jruby-head
 env:
   global:
     - JRUBY_OPTS='--dev -J-Xmx1024M'
+    - COVERAGE='true'
 matrix:
   allow_failures:
     - rvm: ruby-head

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+## Unreleased
+
+## Added
+
+* Introduce `Configurable.finalize!` which freezes config and its dependencies ([qcam](https://github.com/qcam))
+
+## Fixed
+
+* Allow for boolean false as default setting value ([yuszuv](https://github.com/yuszuv))
+* Convert nested configs to nested hashes with `Config#to_h` ([saverio-kantox](https://github.com/saverio-kantox))
+* Disallow modification on frozen config ([qcam](https://github.com/qcam))
+
+[Compare v0.6.2...HEAD](https://github.com/dry-rb/dry-configurable/compare/v0.6.2...HEAD)

data/Gemfile

@@ -3,13 +3,14 @@ source 'https://rubygems.org'
 gemspec
 
 group :test do
-  gem 'codeclimate-test-reporter', platform: :rbx
+  platforms :mri do
+    gem 'codeclimate-test-reporter', require: false
+    gem 'simplecov', require: false
+  end
 end
 
 group :tools do
-  gem 'rubocop'
   gem 'guard'
   gem 'guard-rspec'
-  gem 'guard-rubocop'
   gem 'listen', '3.0.6'
 end

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014 Ruby Object Mapper
+Copyright (c) 2015-2017 dry-rb
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

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,8 +40,14 @@ end
 App.config.database.dsn
 # => 'jdbc:sqlite:memory'
 App.config.adapter # => nil
+App.pool # => 5
+App.uploader.bucket # => 'dev'
 ```
 
+## Links
+
+* [Documentation](http://dry-rb.org/gems/dry-configurable)
+
 ## License
 
 See `LICENSE` file.

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/value.rb

@@ -0,0 +1,27 @@
+module Dry
+  module Configurable
+    class Config
+      # @private
+      class Value
+        # @private
+        NONE = ::Object.new.freeze
+
+        attr_reader :name, :processor
+
+        def initialize(name, value, processor)
+          @name = name.to_sym
+          @value = value
+          @processor = processor
+        end
+
+        def value
+          none? ? nil : @value
+        end
+
+        def none?
+          @value.equal?(::Dry::Configurable::Config::Value::NONE)
+        end
+      end
+    end
+  end
+end

data/lib/dry/configurable/config.rb

@@ -1,7 +1,92 @@
 module Dry
   module Configurable
     # @private
-    class Config < ::Struct
+    class Config
+      DEFAULT_PROCESSOR = ->(v) { v }.freeze
+
+      def self.create(settings)
+        klass = ::Class.new(self)
+
+        settings.each do |setting|
+          klass.__send__(:define_method, setting.name) do
+            @config[setting.name]
+          end
+
+          klass.__send__(:define_method, "#{setting.name}=") do |value|
+            raise_frozen_config if frozen?
+            @config[setting.name] = setting.processor.call(value)
+          end
+        end
+
+        klass.new(settings)
+      end
+
+      def initialize(settings)
+        @config = ::Concurrent::Hash.new
+
+        settings.each do |setting|
+          if setting.none?
+            @config[setting.name] = nil
+          else
+            public_send("#{setting.name}=", setting.value)
+          end
+        end
+      end
+
+      def dup
+        dup = super
+        dup.instance_variable_set(:@config, @config.dup)
+        dup
+      end
+
+      def clone
+        clone = super
+        clone.instance_variable_set(:@config, @config.clone)
+        clone
+      end
+
+      def finalize!
+        @config.freeze
+        freeze
+      end
+
+      def to_h
+        @config.each_with_object({}) do |tuple, hash|
+          key, value = tuple
+
+          case value
+          when ::Dry::Configurable::Config, ::Dry::Configurable::NestedConfig
+            hash[key] = value.to_h
+          else
+            hash[key] = value
+          end
+        end
+      end
+      alias to_hash to_h
+
+      def [](name)
+        raise_unknown_setting_error(name) unless setting?(name)
+        public_send(name)
+      end
+
+      def []=(name, value)
+        raise_unknown_setting_error(name) unless setting?(name)
+        public_send("#{name}=", value)
+      end
+
+      private
+
+      def raise_frozen_config
+        raise FrozenConfig, 'Cannot modify frozen config'
+      end
+
+      def raise_unknown_setting_error(name)
+        raise ArgumentError, "+#{name}+ is not a setting name"
+      end
+
+      def setting?(name)
+        @config.key?(name.to_sym)
+      end
     end
   end
 end

data/lib/dry/configurable/error.rb

@@ -0,0 +1,9 @@
+# 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)
+    FrozenConfig = ::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/test_interface.rb

@@ -0,0 +1,22 @@
+module Dry
+  module Configurable
+    # Methods meant to be used in a testing scenario
+    module TestInterface
+      # Resets configuration to default values
+      #
+      # @return [Dry::Configurable::Config]
+      #
+      # @api public
+      def reset_config
+        create_config
+      end
+    end
+
+    # Mixes in test interface into the configurable module
+    #
+    # @api public
+    def enable_test_interface
+      extend Dry::Configurable::TestInterface
+    end
+  end
+end

data/lib/dry/configurable/version.rb

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

data/lib/dry/configurable.rb

@@ -1,5 +1,9 @@
 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'
 
 # A collection of micro-libraries, each intended to encapsulate
@@ -29,15 +33,17 @@ module Dry
     # @private
     def self.extended(base)
       base.class_eval do
-        @_config_mutex = Mutex.new
-        @_settings = Concurrent::Map.new
+        @_config_mutex = ::Mutex.new
+        @_settings = ::Concurrent::Array.new
+        @_reader_attributes = ::Concurrent::Array.new
       end
     end
 
     # @private
     def inherited(subclass)
-      subclass.instance_variable_set(:@_config_mutex, Mutex.new)
+      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
@@ -49,9 +55,7 @@ module Dry
     # @api public
     def config
       return @_config if defined?(@_config)
-      @_config_mutex.synchronize do
-        @_config ||= Config.new(*_settings.keys).new(*_settings.values) unless _settings.empty?
-      end
+      create_config
     end
 
     # Return configuration
@@ -62,9 +66,20 @@ module Dry
     #
     # @api public
     def configure
+      raise_frozen_config if frozen?
       yield(config) if block_given?
     end
 
+    # Finalize and freeze configuration
+    #
+    # @return [Dry::Configurable::Config]
+    #
+    # @api public
+    def finalize!
+      freeze
+      config.finalize!
+    end
+
     # Add a setting to the configuration
     #
     # @param [Mixed] key
@@ -79,9 +94,32 @@ module Dry
     # @return [Dry::Configurable::Config]
     #
     # @api public
-    def setting(key, default = nil, &block)
-      default = _config_for(&block) if block_given?
-      _settings[key] = default
+    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)
+        else
+          processor = block
+        end
+      end
+
+      _settings << ::Dry::Configurable::Config::Value.new(
+        key,
+        !value.nil? ? 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
+    #
+    # @return [Array]
+    #
+    # @api public
+    def settings
+      _settings.map(&:name)
     end
 
     # @private no, really...
@@ -89,13 +127,59 @@ 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 raise_frozen_config
+      raise FrozenConfig, 'Cannot modify frozen config'
+    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/spec/spec_helper.rb

@@ -1,12 +1,92 @@
-# encoding: utf-8
+if ENV['COVERAGE'] == 'true' && RUBY_ENGINE == 'ruby' && RUBY_VERSION == '2.3.1'
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter '/spec/'
+  end
+end
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # 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'
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the n slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 3
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end
 
 require 'dry/configurable'
+require 'dry/configurable/test_interface'
 
 Dir[Pathname(__FILE__).dirname.join('support/**/*.rb').to_s].each do |file|
   require file
 end
-
-if RUBY_ENGINE == 'rbx'
-  require 'codeclimate-test-reporter'
-  CodeClimate::TestReporter.start
-end