autoloaded 1.4.1 → 1.7.0

data/spec/autoloaded/refine/string/to_source_filename_spec.rb

@@ -1,19 +0,0 @@
-using Autoloaded::Refine::String::ToSourceFilename
-
-RSpec.describe Autoloaded::Refine::String::ToSourceFilename do
-  {'Foo'        => 'foo',
-   'IO'         => 'io',
-   'MySQL2'     => 'my_sql2',
-   'PostgreSQL' => 'postgre_sql',
-   'Geo3D'      => 'geo3_d',
-   'Xfiles'     => 'xfiles',
-   'XFiles'     => 'x_files',
-   'FOOBar'     => 'foo_bar',
-   'FOO_BAR'    => 'foo_bar'}.each do |constant_name, filename|
-    describe "for #{constant_name.inspect}" do
-      describe '#to_source_filename' do
-        specify { expect(constant_name.to_source_filename).to eq(filename) }
-      end
-    end
-  end
-end

data/spec/autoloaded/specification_spec.rb

@@ -1,98 +0,0 @@
-RSpec.describe Autoloaded::Specification do
-  before :each do
-    allow(inflector_class).to receive(:to_constant_name).
-                              and_return(:FromInflection1,
-                                         :FromInflection2,
-                                         :FromInflection3)
-  end
-
-  subject(:specification) { specification_class.new(*elements) }
-
-  let(:specification_class) { described_class }
-
-  let(:inflector_class) { Autoloaded::Inflection }
-
-  specify("equals equivalent #{described_class.name}") {
-    expect(specification_class.new('foo')).to eq(specification_class.new('foo'))
-  }
-
-  specify("doesn't equal #{Object.name}") {
-    expect(specification_class.new('foo')).not_to eq(Object.new)
-  }
-
-  specify("doesn't equal #{described_class.name} with different #elements") {
-    expect(specification_class.new('foo')).not_to eq(specification_class.new('bar'))
-  }
-
-  describe 'with no elements' do
-    let(:elements) { [] }
-
-    specify { expect(specification.match('foo/bar')).to be_nil }
-  end
-
-  describe 'with one nonmatching element' do
-    let(:elements) { ['foo/bar'] }
-
-    specify { expect(specification.match('foo/baz')).to be_nil }
-  end
-
-  describe 'with one matching string element' do
-    let(:elements) { ['FOO/BAR'] }
-
-    specify { expect(specification.match('foo/bar')).to eq(:FromInflection1) }
-  end
-
-  describe 'with one matching symbol element' do
-    let(:elements) { [:FROMINFLECTION1] }
-
-    specify { expect(specification.match('foo/bar')).to eq(:FROMINFLECTION1) }
-  end
-
-  describe 'with two string elements, the second of which is matching' do
-    let(:elements) { %w(foo/bar baz/qux) }
-
-    specify { expect(specification.match('baz/qux')).to eq(:FromInflection1) }
-  end
-
-  describe 'with two symbol elements, the second of which is matching' do
-    let(:elements) { %i(Foo FromInflection2) }
-
-    specify { expect(specification.match('baz/qux')).to eq(:FromInflection2) }
-  end
-
-  describe 'with a nonmatching hash element' do
-    let(:elements) { [{Foo: 'bar/baz'}] }
-
-    specify { expect(specification.match('bar/qux')).to be_nil }
-  end
-
-  describe 'with a hash element in which a key matches' do
-    let(:elements) { [{FromInflection1: 'bar/baz'}] }
-
-    specify { expect(specification.match('foo')).to eq('bar/baz') }
-  end
-
-  describe 'with a hash element in which a value matches' do
-    let(:elements) { [{Foo: 'bar/baz'}] }
-
-    specify { expect(specification.match('bar/baz')).to eq(:Foo) }
-  end
-
-  describe 'with a hash element in which an array key has a match' do
-    let(:elements) { [{%i(Foo FromInflection2) => 'bar/baz'}] }
-
-    specify { expect(specification.match('qux')).to eq('bar/baz') }
-  end
-
-  describe 'with a hash element in which a an array value has a match' do
-    let(:elements) { [{Foo: %w(bar/baz qux/quux)}] }
-
-    specify { expect(specification.match('qux/quux')).to eq(:Foo) }
-  end
-
-  describe 'with a nonmatching string and a hash element in which an array key has a match' do
-    let(:elements) { ['foo', {%i(Bar FromInflection2) => 'baz/qux'}] }
-
-    specify { expect(specification.match('quux')).to eq('baz/qux') }
-  end
-end

data/spec/autoloaded/specifications_spec.rb

@@ -1,191 +0,0 @@
-RSpec.describe Autoloaded::Specifications do
-  subject(:specifications) { specifications_class.new }
-
-  let(:specifications_class) { described_class }
-
-  describe 'empty' do
-    describe '#except' do
-      subject(:except) { specifications.except }
-
-      specify { is_expected.to be_empty }
-    end
-
-    describe '#only' do
-      subject(:only) { specifications.only }
-
-      specify { is_expected.to be_empty }
-    end
-
-    describe '#with' do
-      subject(:with) { specifications.with }
-
-      specify { is_expected.to be_empty }
-    end
-
-    describe '#validate! :except' do
-      specify { expect { specifications.validate! :except }.not_to raise_error }
-    end
-
-    describe '#validate! :only' do
-      specify { expect { specifications.validate! :only }.not_to raise_error }
-    end
-
-    describe '#validate! :with' do
-      specify { expect { specifications.validate! :with }.not_to raise_error }
-    end
-  end
-
-  describe 'with #except' do
-    before :each do
-      specifications.except << :foo
-    end
-
-    describe '#except' do
-      subject(:except) { specifications.except }
-
-      specify { is_expected.to contain_exactly(:foo) }
-    end
-
-    describe '#only' do
-      subject(:only) { specifications.only }
-
-      specify { is_expected.to be_empty }
-    end
-
-    describe '#with' do
-      subject(:with) { specifications.with }
-
-      specify { is_expected.to be_empty }
-    end
-
-    describe '#validate! :except' do
-      specify { expect { specifications.validate! :except }.not_to raise_error }
-    end
-
-    describe '#validate! :only' do
-      specify { expect { specifications.validate! :only }.not_to raise_error }
-    end
-
-    describe '#validate! :with' do
-      specify { expect { specifications.validate! :with }.not_to raise_error }
-    end
-
-    describe 'and #only' do
-      before :each do
-        specifications.only << :bar
-      end
-
-      describe '#except' do
-        subject(:except) { specifications.except }
-
-        specify { is_expected.to contain_exactly(:foo) }
-      end
-
-      describe '#only' do
-        subject(:only) { specifications.only }
-
-        specify { is_expected.to contain_exactly(:bar) }
-      end
-
-      describe '#with' do
-        subject(:with) { specifications.with }
-
-        specify { is_expected.to be_empty }
-      end
-
-      describe '#validate! :except' do
-        specify {
-          expect {
-            specifications.validate! :except
-          }.to raise_error(RuntimeError,
-                           "can't specify `except' when `only' is already specified")
-        }
-      end
-
-      describe '#validate! :only' do
-        specify {
-          expect {
-            specifications.validate! :only
-          }.to raise_error(RuntimeError,
-                           "can't specify `only' when `except' is already specified")
-        }
-      end
-
-      describe '#validate! :with' do
-        specify { expect { specifications.validate! :with }.not_to raise_error }
-      end
-    end
-  end
-
-  describe 'with #only' do
-    before :each do
-      specifications.only << :foo
-    end
-
-    describe '#except' do
-      subject(:except) { specifications.except }
-
-      specify { is_expected.to be_empty }
-    end
-
-    describe '#only' do
-      subject(:only) { specifications.only }
-
-      specify { is_expected.to contain_exactly(:foo) }
-    end
-
-    describe '#with' do
-      subject(:with) { specifications.with }
-
-      specify { is_expected.to be_empty }
-    end
-
-    describe '#validate! :except' do
-      specify { expect { specifications.validate! :except }.not_to raise_error }
-    end
-
-    describe '#validate! :only' do
-      specify { expect { specifications.validate! :only }.not_to raise_error }
-    end
-
-    describe '#validate! :with' do
-      specify { expect { specifications.validate! :with }.not_to raise_error }
-    end
-  end
-
-  describe 'with #with' do
-    before :each do
-      specifications.with << :foo
-    end
-
-    describe '#except' do
-      subject(:except) { specifications.except }
-
-      specify { is_expected.to be_empty }
-    end
-
-    describe '#only' do
-      subject(:only) { specifications.only }
-
-      specify { is_expected.to be_empty }
-    end
-
-    describe '#with' do
-      subject(:with) { specifications.with }
-
-      specify { is_expected.to contain_exactly(:foo) }
-    end
-
-    describe '#validate! :except' do
-      specify { expect { specifications.validate! :except }.not_to raise_error }
-    end
-
-    describe '#validate! :only' do
-      specify { expect { specifications.validate! :only }.not_to raise_error }
-    end
-
-    describe '#validate! :with' do
-      specify { expect { specifications.validate! :with }.not_to raise_error }
-    end
-  end
-end

data/spec/autoloaded/version_spec.rb

@@ -1,3 +0,0 @@
-RSpec.describe "#{Autoloaded.name}::VERSION" do
-  specify { expect(Autoloaded::VERSION).to match( /^\d+\.\d+\.\d+/ ) }
-end

data/spec/autoloaded/warning_spec.rb

@@ -1,115 +0,0 @@
-require 'stringio'
-
-RSpec.describe Autoloaded::Warning do
-  before :each do
-    warning_module.io = io
-  end
-
-  let(:warning_module) { described_class }
-
-  let(:io) { StringIO.new }
-
-  describe '.enable' do
-    describe 'simple form' do
-      describe 'with nil argument' do
-        specify('sets .enabled? as expected') {
-          warning_module.enable nil
-          expect(warning_module.enabled?).to eq(false)
-        }
-      end
-
-      describe 'with false argument' do
-        specify('sets .enabled? as expected') {
-          warning_module.enable false
-          expect(warning_module.enabled?).to eq(false)
-        }
-      end
-
-      describe 'with string argument' do
-        specify('sets .enabled? as expected') {
-          warning_module.enable 'foo'
-          expect(warning_module.enabled?).to eq(true)
-        }
-      end
-
-      describe 'with true argument' do
-        specify('sets .enabled? as expected') {
-          warning_module.enable true
-          expect(warning_module.enabled?).to eq(true)
-        }
-      end
-
-      specify("returns #{Autoloaded::Warning.name}") {
-        expect(warning_module.enable('foo')).to eq(warning_module)
-      }
-    end
-
-    describe 'block form' do
-      specify('returns the result of the block') {
-        result = warning_module.enable('foo') do
-          :block_result
-        end
-        expect(result).to eq(:block_result)
-      }
-
-      describe 'if the block returns' do
-        specify('resets .enabled?') {
-          expect {
-            warning_module.enable(false) { }
-          }.not_to change { warning_module.enabled? }
-          expect {
-            warning_module.enable(true) { }
-          }.not_to change { warning_module.enabled? }
-        }
-      end
-
-      describe 'if the block raises an error' do
-        specify('resets .enabled?') {
-          expect {
-            begin
-              warning_module.enable(false) do
-                1 / 0
-              end
-            rescue ZeroDivisionError
-            end
-          }.not_to change { warning_module.enabled? }
-          expect {
-            begin
-              warning_module.enable(true) do
-                1 / 0
-              end
-            rescue ZeroDivisionError
-            end
-          }.not_to change { warning_module.enabled? }
-        }
-      end
-    end
-  end
-
-  describe '.changing_autoload' do
-    before :each do
-      warning_module.enable true
-      warning_module.changing_autoload constant_name:        :Foo,
-                                       old_source_filename:  'bar',
-                                       new_source_filename:  'baz',
-                                       host_source_location: 'qux.rb:123'
-    end
-
-    specify('writes the expected message to .io') {
-      expect(io.string).to eq(%Q(\e[33m*** \e[7m WARNING \e[0m Existing autoload of \e[4mFoo\e[0m from "bar" is being overridden to autoload from "baz" -- avoid this warning by using an \e[4monly\e[0m or an \e[4mexcept\e[0m specification in the block at qux.rb:123\n))
-    }
-  end
-
-  describe '.existing_constant' do
-    before :each do
-      warning_module.enable true
-      warning_module.existing_constant constant_name:        :Foo,
-                                       source_filename:      'bar',
-                                       host_source_location: 'baz.rb:123'
-    end
-
-    specify('writes the expected message to .io') {
-      expect(io.string).to eq(%Q(\e[33m*** \e[7m WARNING \e[0m Existing definition of \e[4mFoo\e[0m obviates autoloading from "bar" -- avoid this warning by using an \e[4monly\e[0m or an \e[4mexcept\e[0m specification in the block at baz.rb:123\n))
-    }
-  end
-end

data/spec/autoloaded_macro_sharedspec.rb

@@ -1,24 +0,0 @@
-RSpec.shared_examples_for "an #{Autoloaded.name} macro" do |macro|
-  before :each do
-    allow(autoloader_class).to receive(:new).and_return(autoloader)
-    allow_any_instance_of(autoloader_class).to receive(:autoload!)
-  end
-
-  let(:autoloaded_module) { Autoloaded }
-
-  let(:autoloader) { autoloader_class.new binding }
-
-  let(:autoloader_class) { autoloaded_module::Autoloader }
-
-  specify("yields an #{Autoloaded::Autoloader.name}") {
-    autoloaded_module.send macro do |autoloaded|
-      expect(autoloaded).to equal(autoloader)
-    end
-  }
-
-  specify("calls #{Autoloaded::Autoloader.name}#autoload!") {
-    expect(autoloader).to receive(:autoload!)
-    autoloaded_module.send macro do |autoloaded|
-    end
-  }
-end