dry-configurable 0.9.0

data/Gemfile

@@ -0,0 +1,20 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  platforms :mri do
+    gem 'codeclimate-test-reporter', require: false
+    gem 'simplecov', require: false
+  end
+
+  gem 'warning'
+end
+
+group :tools do
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'listen', '3.0.6'
+  gem 'pry-byebug', platform: :mri
+  gem "ossy", git: "https://github.com/solnic/ossy.git", branch: "master"
+end

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2019 dry-rb team
+
+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
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+[gitter]: https://gitter.im/dry-rb/chat
+[gem]: https://rubygems.org/gems/dry-configurable
+[travis]: https://travis-ci.org/dry-rb/dry-configurable
+[inch]: http://inch-ci.org/github/dry-rb/dry-configurable
+[chat]: https://dry-rb.zulipchat.com
+
+# dry-configurable [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
+
+[![Gem Version](https://img.shields.io/gem/v/dry-configurable.svg)][gem]
+[![Build Status](https://img.shields.io/travis/dry-rb/dry-configurable.svg)][travis]
+[![Maintainability](https://api.codeclimate.com/v1/badges/25311e81391498d6b7c8/maintainability)](https://codeclimate.com/github/dry-rb/dry-configurable/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/25311e81391498d6b7c8/test_coverage)](https://codeclimate.com/github/dry-rb/dry-configurable/test_coverage)
+[![API Documentation Coverage](http://inch-ci.org/github/dry-rb/dry-configurable.svg)][inch]
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dry-configurable'
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install dry-configurable
+```
+
+## Links
+
+* [Documentation](http://dry-rb.org/gems/dry-configurable)
+
+## License
+
+See `LICENSE` file.

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+task default: :spec
+
+desc 'Run all specs in spec directory'
+RSpec::Core::RakeTask.new(:spec)

data/docsite/source/index.html.md

@@ -0,0 +1,55 @@
+---
+title: Introduction & Usage
+description: Thread-safe configuration mixin
+layout: gem-single
+order: 7
+type: gem
+name: dry-configurable
+sections:
+  - testing
+---
+
+### Introduction
+
+`dry-configurable` is a simple mixin to add thread-safe configuration behaviour to your classes. There are many libraries that make use of configuration, and each seemed to have their own implementation with a similar or duplicate interface, so we thought it was strange that this behaviour had not already been encapsulated into a reusable gem, hence `dry-configurable` was born.
+
+### Usage
+
+`dry-configurable` is extremely simple to use, just extend the mixin and use the `setting` macro to add configuration options:
+
+```ruby
+class App
+  extend Dry::Configurable
+
+  # Pass a block for nested configuration (works to any depth)
+  setting :database do
+    # Can pass a default value
+    setting :dsn, 'sqlite:memory'
+  end
+  # Defaults to nil if no default value is given
+  setting :adapter
+  # Pre-process values
+  setting(:path, 'test') { |value| Pathname(value) }
+  # Passing the reader option as true will create attr_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.config.database.dsn
+# => "sqlite:memory"
+
+App.config.database.dsn = 'jdbc:sqlite:memory'
+App.config.database.dsn
+# => "jdbc:sqlite:memory"
+App.config.adapter
+# => nil
+App.config.path
+# => #<Pathname:test>
+App.pool
+# => 5
+App.uploader.bucket
+# => 'dev'
+```

data/docsite/source/testing.html.md

@@ -0,0 +1,27 @@
+---
+title: Testing
+layout: gem-single
+name: dry-configurable
+---
+
+### How to reset the config to its original state on testing environment
+
+update `spec_helper.rb` :
+
+```ruby
+require "dry/configurable/test_interface"
+
+# this is your module/class that extended by Dry::Configurable
+module AwesomeModule
+  enable_test_interface
+end
+```
+
+and on spec file (`xxx_spec.rb`) :
+
+```ruby 
+before(:all) { AwesomeModule.reset_config }
+# or 
+before(:each) { AwesomeModule.reset_config }
+
+```

data/dry-configurable.gemspec

@@ -0,0 +1,29 @@
+require File.expand_path('../lib/dry/configurable/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dry-configurable'
+  spec.version       = Dry::Configurable::VERSION
+  spec.authors       = ['Andy Holland']
+  spec.email         = ['andyholland1991@aol.com']
+  spec.summary       = 'A mixin to add configuration functionality to your classes'
+  spec.homepage      = 'https://github.com/dry-rb/dry-configurable'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec|bin)/}) }
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.metadata = {
+    'source_code_uri' => 'https://github.com/dry-rb/dry-configurable',
+    'changelog_uri' => 'https://github.com/dry-rb/dry-configurable/blob/master/CHANGELOG.md'
+  }
+
+  spec.required_ruby_version = ">= 2.4.0"
+  spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
+  spec.add_runtime_dependency 'dry-core', '~> 0.4', '>= 0.4.7'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/lib/dry-configurable.rb

@@ -0,0 +1 @@
+require 'dry/configurable'

data/lib/dry/configurable.rb

@@ -0,0 +1,191 @@
+require 'dry/core/constants'
+require 'dry/configurable/settings'
+require 'dry/configurable/error'
+require 'dry/configurable/version'
+
+# A collection of micro-libraries, each intended to encapsulate
+# a common task in Ruby
+module Dry
+  # A simple configuration mixin
+  #
+  # @example class-level configuration
+  #
+  #   class App
+  #     extend Dry::Configurable
+  #
+  #     setting :database do
+  #       setting :dsn, 'sqlite:memory'
+  #     end
+  #   end
+  #
+  #   App.config.database.dsn = 'jdbc:sqlite:memory'
+  #   App.config.database.dsn
+  #     # => "jdbc:sqlite:memory"
+  #
+  # @example instance-level configuration
+  #
+  #   class App
+  #     include Dry::Configurable
+  #
+  #     setting :database
+  #   end
+  #
+  #   production = App.new
+  #   production.config.database = ENV['DATABASE_URL']
+  #   production.finalize!
+  #
+  #   development = App.new
+  #   development.config.database = 'jdbc:sqlite:memory'
+  #   development.finalize!
+  #
+  # @api public
+  module Configurable
+    include Dry::Core::Constants
+
+    module ClassMethods
+      # @private
+      def self.extended(base)
+        base.instance_exec do
+          @settings = Settings.new
+        end
+      end
+
+      # Add a setting to the configuration
+      #
+      # @param [Mixed] key
+      #   The accessor key for the configuration value
+      # @param [Mixed] default
+      #   The default config value
+      #
+      # @yield
+      #   If a block is given, it will be evaluated in the context of
+      #   a new configuration class, and bound as the default value
+      #
+      # @return [Dry::Configurable::Config]
+      #
+      # @api public
+      def setting(key, value = Undefined, options = Undefined, &block)
+        raise_already_defined_config(key) if _settings.config_defined?
+
+        setting = _settings.add(key, value, options, &block)
+
+        if setting.reader?
+          readers = singleton_class < Configurable ? singleton_class : self
+          readers.send(:define_method, setting.name) { config[setting.name] }
+        end
+      end
+
+      # Return an array of setting names
+      #
+      # @return [Set]
+      #
+      # @api public
+      def settings
+        _settings.names
+      end
+
+      # @private no, really...
+      def _settings
+        @settings
+      end
+
+      private
+
+      # @private
+      def raise_already_defined_config(key)
+        raise AlreadyDefinedConfig,
+              "Cannot add setting +#{key}+, #{self} is already configured"
+      end
+
+      # @private
+      def inherited(subclass)
+        parent = self
+        subclass.instance_exec do
+          @settings = parent._settings.dup
+        end
+
+        if singleton_class < Configurable
+          parent_config = @config
+          subclass.instance_exec do
+            @config = _settings.create_config
+            @config.define!(parent_config.to_h) if parent_config.defined?
+          end
+        end
+
+        super
+      end
+    end
+
+    class << self
+      # @private
+      def extended(base)
+        base.extend(ClassMethods)
+        base.class_eval do
+          @config = _settings.create_config
+        end
+      end
+
+      # @private
+      def included(base)
+        base.extend(ClassMethods)
+      end
+    end
+
+    # @private
+    def initialize(*)
+      @config = self.class._settings.create_config
+      super
+    end
+
+    # Return configuration
+    #
+    # @return [Dry::Configurable::Config]
+    #
+    # @api public
+    def config
+      return @config if @config.defined?
+      @config.define!
+    end
+
+    # Return configuration
+    #
+    # @yield [Dry::Configuration::Config]
+    #
+    # @return [Dry::Configurable::Config]
+    #
+    # @api public
+    def configure
+      raise FrozenConfig, 'Cannot modify frozen config' if frozen?
+      yield(config) if block_given?
+      self
+    end
+
+    # Finalize and freeze configuration
+    #
+    # @return [Dry::Configurable::Config]
+    #
+    # @api public
+    def finalize!
+      freeze
+      config.finalize!
+    end
+
+    # @api public
+    def dup
+      super.tap do |copy|
+        copy.instance_variable_set(:@config, config.dup)
+      end
+    end
+
+    # @api public
+    def clone
+      if frozen?
+        super
+      else
+        super.tap do |copy|
+          copy.instance_variable_set(:@config, config.dup)
+        end
+      end
+    end
+  end
+end

data/lib/dry/configurable/config.rb

@@ -0,0 +1,185 @@
+require 'concurrent/hash'
+
+module Dry
+  module Configurable
+    # @private
+    class Config
+      class << self
+        # @private
+        def [](settings)
+          ::Class.new(Config) do
+            @settings = settings
+            singleton_class.send(:attr_reader, :settings)
+
+            @lock = ::Mutex.new
+            @config_defined = false
+          end
+        end
+
+        # @private
+        def define_accessors!
+          @lock.synchronize do
+            break if config_defined?
+
+            settings.each do |setting|
+              next if setting.reserved?
+
+              define_method(setting.name) do
+                @config[setting.name]
+              end
+
+              define_method("#{setting.name}=") do |value|
+                raise FrozenConfig, 'Cannot modify frozen config' if frozen?
+                @config[setting.name] = setting.processor.(value)
+              end
+            end
+
+            @config_defined = true
+          end
+        end
+
+        # @private
+        def config_defined?
+          @config_defined
+        end
+      end
+
+      def initialize
+        @config = ::Concurrent::Hash.new
+        @lock = ::Mutex.new
+        @defined = false
+      end
+
+      def defined?
+        @defined
+      end
+
+      # @private
+      def define!(parent_config = EMPTY_HASH)
+        @lock.synchronize do
+          break if self.defined?
+
+          self.class.define_accessors!
+          set_values!(parent_config)
+
+          @defined = true
+        end
+
+        self
+      end
+
+      # @private
+      def finalize!
+        define!
+        @config.freeze
+        freeze
+      end
+
+      # Serialize config to a Hash
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def to_h
+        @config.each_with_object({}) do |(key, value), hash|
+          case value
+          when Config
+            hash[key] = value.to_h
+          else
+            hash[key] = value
+          end
+        end
+      end
+      alias to_hash to_h
+
+      # Get config value by a key
+      #
+      # @param [String,Symbol] name
+      #
+      # @return Config value
+      def [](name)
+        setting = self.class.settings[name.to_sym]
+
+        if setting.nil?
+          raise_unknown_setting_error(name)
+        elsif setting.reserved?
+          @config[setting.name]
+        else
+          public_send(name)
+        end
+      end
+
+      # Set config value.
+      # Note that finalized configs cannot be changed.
+      #
+      # @param [String,Symbol] name
+      # @param [Object] value
+      def []=(name, value)
+        setting = self.class.settings[name.to_sym]
+
+        if setting.nil?
+          raise_unknown_setting_error(name)
+        elsif setting.reserved?
+          @config[setting.name] = setting.processor.(value)
+        else
+          public_send("#{name}=", value)
+        end
+      end
+
+      # Whether config has a key
+      #
+      # @param [Symbol] key
+      # @return [Bool]
+      def key?(name)
+        self.class.settings.name?(name)
+      end
+
+      # Recursively update values from a hash
+      #
+      # @param [Hash] values to set
+      # @return [Config]
+      def update(values)
+        values.each do |key, value|
+          if self[key].is_a?(Config)
+            self[key].update(value)
+          else
+            self[key] = value
+          end
+        end
+        self
+      end
+
+      def dup
+        if self.defined?
+          self.class.new.define!(to_h)
+        else
+          self.class.new
+        end
+      end
+
+      private
+
+      # @private
+      def set_values!(parent)
+        self.class.settings.each do |setting|
+          if parent.key?(setting.name) && !setting.node?
+            @config[setting.name] = parent[setting.name]
+          elsif setting.undefined?
+            @config[setting.name] = nil
+          elsif setting.node?
+            value = setting.value.create_config
+            value.define!(parent.fetch(setting.name, EMPTY_HASH))
+            self[setting.name] = value
+          else
+            self[setting.name] = setting.value
+          end
+        end
+      end
+
+      # @private
+      def raise_unknown_setting_error(name)
+        ::Kernel.raise ArgumentError, "+#{name}+ is not a setting name"
+      end
+    end
+  end
+end