dry-configurable 0.7.0 → 0.8.0

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

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

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

@@ -1,55 +0,0 @@
-RSpec.describe Dry::Configurable::Config::Value do
-  let(:klass) { Dry::Configurable::Config::Value }
-  let(:config) { klass.new(name, value, processor) }
-  let(:name) { :db }
-  let(:value) { 'test' }
-  let(:processor) { ->(v) { v } }
-
-  describe '#initialize' do
-    it 'coerces string name to symbol' do
-      config = klass.new('db', value, processor)
-
-      expect(config.name).to eq(:db)
-    end
-  end
-
-  describe '#name' do
-    subject! { config.name }
-
-    it { is_expected.to eq(name) }
-  end
-
-  describe '#value' do
-    subject! { config.value }
-
-    context 'when value is not NONE' do
-      it { is_expected.to eq(value) }
-    end
-
-    context 'when value is NONE' do
-      let(:value) { klass::NONE }
-
-      it { is_expected.to be(nil) }
-    end
-  end
-
-  describe '#processor' do
-    subject! { config.processor }
-
-    it { is_expected.to eq(processor) }
-  end
-
-  describe '#none?' do
-    subject! { config.none? }
-
-    context 'when value is not NONE' do
-      it { is_expected.to be(false) }
-    end
-
-    context 'when value is NONE' do
-      let(:value) { klass::NONE }
-
-      it { is_expected.to be(true) }
-    end
-  end
-end