dry-configurable 0.7.0 → 0.8.3

data/.ruby-version

@@ -1 +0,0 @@
-2.0.0-p247

data/lib/dry/configurable/argument_parser.rb

@@ -1,91 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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/nested_config.rb

@@ -1,33 +0,0 @@
-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/spec/integration/configurable_spec.rb

@@ -1,25 +0,0 @@
-RSpec.describe Dry::Configurable do
-  context 'when extended' do
-    let(:klass) do
-      Class.new do
-        extend Dry::Configurable
-      end
-    end
-
-    it_behaves_like 'a configurable class'
-  end
-
-  context 'when extended then inherited' do
-    let(:base_klass) do
-      Class.new do
-        extend Dry::Configurable
-      end
-    end
-
-    let(:klass) do
-      Class.new(base_klass)
-    end
-
-    it_behaves_like 'a configurable class'
-  end
-end

data/spec/spec_helper.rb

@@ -1,92 +0,0 @@
-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

data/spec/support/shared_examples/configurable.rb

@@ -1,391 +0,0 @@
-RSpec.shared_examples 'a configurable class' do
-  describe Dry::Configurable do
-    describe 'settings' do
-      context 'without processor option' do
-        context 'without default value' do
-          before do
-            klass.setting :dsn
-          end
-
-          it 'returns nil' do
-            expect(klass.config.dsn).to be(nil)
-          end
-        end
-
-        context 'with default value' do
-          context 'with a nil default value' do
-            before do
-              klass.setting :dsn, nil
-            end
-
-            it 'returns the default value' do
-              expect(klass.config.dsn).to be(nil)
-            end
-          end
-
-          context 'with a false default value' do
-            before do
-              klass.setting :dsn, false
-            end
-
-            it 'returns the default value' do
-              expect(klass.config.dsn).to be(false)
-            end
-          end
-
-          context 'with a string default value' do
-            before do
-              klass.setting :dsn, 'sqlite:memory'
-            end
-
-            it 'returns the default value' do
-              expect(klass.config.dsn).to eq('sqlite:memory')
-            end
-          end
-
-          context 'with a hash default value' do
-            before do
-              klass.setting :db_config, {
-                user: 'root',
-                password: ''
-              }
-            end
-
-            it 'returns the default value' do
-              expect(klass.config.db_config).to eq(
-                user: 'root',
-                password: ''
-              )
-            end
-          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
-              setting :dsn, 'sqlite:memory'
-            end
-          end
-
-          it 'returns the default value' do
-            expect(klass.config.database.dsn).to eq('sqlite:memory')
-          end
-        end
-      end
-
-      context 'with processor' do
-        context 'without default value' do
-          before do
-            klass.setting(:dsn) { |dsn| "sqlite:#{dsn}" }
-          end
-
-          it 'returns nil' do
-            expect(klass.config.dsn).to be(nil)
-          end
-        end
-
-        context 'with default value' do
-          before do
-            klass.setting(:dsn, 'memory') { |dsn| "sqlite:#{dsn}" }
-          end
-
-          it 'returns the default value' do
-            expect(klass.config.dsn).to eq('sqlite:memory')
-          end
-        end
-
-        context 'nested configuration' do
-          before do
-            klass.setting :database do
-              setting(:dsn, 'memory') { |dsn| "sqlite:#{dsn}" }
-            end
-          end
-
-          it 'returns the default value' do
-            expect(klass.config.database.dsn).to eq('sqlite:memory')
-          end
-        end
-      end
-    end
-
-    describe 'configuration' do
-      context 'without nesting' do
-        context 'without processor' do
-          before do
-            klass.setting :dsn, 'sqlite:memory'
-          end
-
-          before do
-            klass.configure do |config|
-              config.dsn = 'jdbc:sqlite:memory'
-            end
-          end
-
-          it 'updates the config value' do
-            expect(klass.config.dsn).to eq('jdbc:sqlite:memory')
-          end
-        end
-
-        context 'with processor' do
-          before do
-            klass.setting(:dsn, 'sqlite') { |dsn| "#{dsn}:memory" }
-          end
-
-          before do
-            klass.configure do |config|
-              config.dsn = 'jdbc:sqlite'
-            end
-          end
-
-          it 'updates the config value' do
-            expect(klass.config.dsn).to eq('jdbc:sqlite:memory')
-          end
-        end
-      end
-
-      context 'with nesting' do
-        context 'without processor' do
-          before do
-            klass.setting :database do
-              setting :dsn, 'sqlite:memory'
-            end
-
-            klass.configure do |config|
-              config.database.dsn = 'jdbc:sqlite:memory'
-            end
-          end
-
-          it 'updates the config value' do
-            expect(klass.config.database.dsn).to eq('jdbc:sqlite:memory')
-          end
-        end
-
-        context 'with processor' do
-          before do
-            klass.setting :database do
-              setting(:dsn, 'sqlite') { |dsn| "#{dsn}:memory" }
-            end
-
-            klass.configure do |config|
-              config.database.dsn = 'jdbc:sqlite'
-            end
-          end
-
-          it 'updates the config value' do
-            expect(klass.config.database.dsn).to eq('jdbc:sqlite:memory')
-          end
-        end
-      end
-
-      context 'when finalized' do
-        before do
-          klass.setting :dsn
-          klass.configure do |config|
-            config.dsn = 'jdbc:sqlite'
-          end
-          klass.finalize!
-        end
-
-        it 'disallows modification' do
-          expect do
-            klass.configure do |config|
-              config.dsn = 'jdbc:sqlite'
-            end
-          end.to raise_error(Dry::Configurable::FrozenConfig, 'Cannot modify frozen config')
-        end
-
-        it 'disallows direct modification on config' do
-          expect do
-            klass.config.dsn = 'jdbc:sqlite:memory'
-          end.to raise_error(Dry::Configurable::FrozenConfig, 'Cannot modify frozen config')
-        end
-      end
-
-      context 'when inherited' do
-        context 'without processor' do
-          before do
-            klass.setting :dsn
-            klass.configure do |config|
-              config.dsn = 'jdbc:sqlite:memory'
-            end
-          end
-
-          subject!(:subclass) { Class.new(klass) }
-
-          it 'retains its configuration' do
-            expect(subclass.config.dsn).to eq('jdbc:sqlite:memory')
-          end
-
-          context 'when the inherited config is modified' do
-            before do
-              subclass.configure do |config|
-                config.dsn = 'jdbc:sqlite:file'
-              end
-            end
-
-            it 'does not modify the original' do
-              expect(klass.config.dsn).to eq('jdbc:sqlite:memory')
-              expect(subclass.config.dsn).to eq('jdbc:sqlite:file')
-            end
-          end
-        end
-
-        context 'with processor' do
-          before do
-            klass.setting(:dsn) { |dsn| "#{dsn}:memory" }
-            klass.configure do |config|
-              config.dsn = 'jdbc:sqlite'
-            end
-          end
-
-          subject!(:subclass) { Class.new(klass) }
-
-          it 'retains its configuration' do
-            expect(subclass.config.dsn).to eq('jdbc:sqlite:memory')
-          end
-
-          context 'when the inherited config is modified' do
-            before do
-              subclass.configure do |config|
-                config.dsn = 'sqlite'
-              end
-            end
-
-            it 'does not modify the original' do
-              expect(klass.config.dsn).to eq('jdbc:sqlite:memory')
-              expect(subclass.config.dsn).to eq('sqlite:memory')
-            end
-          end
-        end
-
-        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
-          end
-
-          subject!(:subclass) { Class.new(klass) }
-
-          it 'does not modify the original' do
-            expect(klass.settings).to_not include(:db)
-          end
-        end
-      end
-    end
-
-    context 'Test Interface' do
-      before { klass.enable_test_interface }
-
-      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
-        end
-
-        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