autoloaded 1.4.1 → 1.5.0

data/spec/autoloaded/constant_spec.rb

@@ -1,53 +0,0 @@
-RSpec.describe Autoloaded::Constant do
-  let(:constant_class) { described_class }
-
-  specify("sanity check: load path includes our 'spec' directory") {
-    expect($:).to include(File.expand_path('../..', __FILE__))
-  }
-
-  describe 'for' do
-    let(:directory) { File.expand_path '../../fixtures/filenames', __FILE__ }
-
-    let(:load_pathed_directory) {
-      directory.gsub(/^#{File.expand_path '../..', __FILE__}\/?/, '')
-    }
-
-    {AFilename:  %w(a_filename  a-file-name a-filename a_file_name             afile_name afile-name AFilename),
-     A_FILENAME: %w(a_filename  a-file-name a-filename a_file_name             afile_name afile-name AFilename),
-     AFileName:  %w(a_file_name a-file-name a-filename             a_filename  afile_name afile-name AFilename),
-     AFILEName:  %w(afile_name  a-file-name a-filename a_file_name a_filename             afile-name AFilename)}.each do |constant_name,
-                                                                                                                          filenames|
-      describe constant_name.inspect do
-        let(:constant) { constant_class.new constant_name }
-
-        let(:load_pathed_filenames) {
-          filenames.collect do |filename|
-            "#{load_pathed_directory}/#{filename}"
-          end
-        }
-
-        describe '#each_matching_filename_in' do
-          let(:yielded_args) {
-            result = []
-            constant.each_matching_filename_in directory do |filename|
-              result << filename
-            end
-            result
-          }
-
-          describe 'first yielded argument' do
-            subject(:first_yielded_argument) { yielded_args.first }
-
-            it { is_expected.to eq(load_pathed_filenames.first) }
-          end
-
-          describe 'subsequent yielded arguments' do
-            subject(:subsequent_yielded_arguments) { yielded_args[1..-1] }
-
-            it { is_expected.to match_array(load_pathed_filenames[1..-1]) }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/autoloaded/deprecation_spec.rb

@@ -1,23 +0,0 @@
-require 'stringio'
-
-RSpec.describe Autoloaded::Deprecation do
-  before :each do
-    deprecation_module.io = io
-  end
-
-  let(:deprecation_module) { described_class }
-
-  let(:io) { StringIO.new }
-
-  describe '.deprecate' do
-    before :each do
-      deprecation_module.deprecate deprecated_usage: 'foo',
-                                   sanctioned_usage: 'bar',
-                                   source_filename:  'baz.rb'
-    end
-
-    specify('writes the expected message to .io') {
-      expect(io.string).to eq(%Q(\e[33m*** \e[7m DEPRECATED \e[0m \e[4mfoo\e[0m -- use \e[4mbar\e[0m instead in baz.rb\n))
-    }
-  end
-end

data/spec/autoloaded/inflection_spec.rb

@@ -1,30 +0,0 @@
-RSpec.describe Autoloaded::Inflection do
-  subject(:inflection_module) { described_class }
-
-  def self.make_source_filename(source_basename)
-    "path/to/#{source_basename}.rb"
-  end
-
-  {'x'         => :X,
-   'foo_bar'   => :FooBar,
-   'foo__bar'  => :FooBar,
-   '__foo_bar' => :FooBar,
-   'foo-bar'   => :FooBar,
-   'foo--bar'  => :FooBar,
-   '--foo-bar' => :FooBar,
-   'FooBar'    => :FooBar,
-   'FOO_BAR'   => :FOO_BAR,
-   'FOO-BAR'   => :FOO_BAR,
-   'FOO--BAR'  => :FOO_BAR,
-   'foo7bar'   => :Foo7bar}.each do |source_basename, expected_constant_name|
-    describe %Q{for #{make_source_filename(source_basename).inspect}"} do
-      describe '#to_constant_name' do
-        specify {
-          source_filename = self.class.make_source_filename(source_basename)
-          constant_name   = inflection_module.to_constant_name(source_filename)
-          expect(constant_name).to eq(expected_constant_name)
-        }
-      end
-    end
-  end
-end

data/spec/autoloaded/load_pathed_directory_spec.rb

@@ -1,120 +0,0 @@
-RSpec.describe Autoloaded::LoadPathedDirectory do
-  before :each do
-    allow(directory_class).to receive(:ruby_load_paths).
-                              and_return(ruby_load_paths)
-  end
-
-  subject(:directory) { directory_class.new path }
-
-  let(:directory_class) { described_class }
-
-  let(:ruby_load_paths) { [Dir.pwd] }
-
-  describe '.new' do
-    describe 'with a nil argument' do
-      specify {
-        expect { directory_class.new nil }.to raise_error(ArgumentError,
-                                                          "can't be nil")
-      }
-    end
-
-    describe 'with a relative-path argument' do
-      specify {
-        expect { directory_class.new 'foo' }.to raise_error(ArgumentError,
-                                                            "can't be relative")
-      }
-    end
-  end
-
-  describe 'with an absolute #path' do
-    let(:path) { File.expand_path 'spec/fixtures/filenames' }
-
-    let(:expected_relative_source_filenames) {
-      %w(a-file-name
-         a-filename
-         a_file_name
-         a_filename
-         afile-name
-         afile_name
-         AFilename)
-    }
-
-    describe '#path' do
-      subject { directory.path }
-
-      specify { is_expected.to eq(path) }
-    end
-
-    describe '#each_source_filename' do
-      subject(:yielded_arguments) {
-        result = []
-        directory.each_source_filename do |source_filename|
-          result << source_filename
-        end
-        result
-      }
-
-      describe 'where #path does not match a Ruby load path' do
-        let(:ruby_load_paths) { [] }
-
-        let(:expected_source_filenames) {
-          expected_relative_source_filenames.collect do |f|
-            File.expand_path f, 'spec/fixtures/filenames'
-          end
-        }
-
-        describe 'yielded arguments' do
-          specify('should be absolute paths to the expected source filenames') {
-            is_expected.to match_array(expected_source_filenames)
-          }
-        end
-      end
-
-      describe 'where #path partially matches one Ruby load path' do
-        let(:expected_source_filenames) {
-          expected_relative_source_filenames.collect do |f|
-            File.join 'spec/fixtures/filenames', f
-          end
-        }
-
-        describe 'yielded arguments' do
-          specify('should be partial paths to the expected source filenames') {
-            is_expected.to match_array(expected_source_filenames)
-          }
-        end
-      end
-
-      describe 'where #path partially matches multiple Ruby load paths' do
-        let(:ruby_load_paths) {
-          [Dir.pwd,
-           File.join(Dir.pwd, 'spec/fixtures'),
-           File.join(Dir.pwd, 'spec')]
-        }
-
-        let(:expected_source_filenames) {
-          expected_relative_source_filenames.collect do |f|
-            File.join 'filenames', f
-          end
-        }
-
-        describe 'yielded arguments' do
-          specify('should be partial paths to the expected source filenames') {
-            is_expected.to match_array(expected_source_filenames)
-          }
-        end
-      end
-
-      describe 'where #path exactly matches a Ruby load path' do
-        let(:ruby_load_paths) { [File.join(Dir.pwd, 'spec/fixtures/filenames')] }
-
-        let(:expected_source_filenames) { expected_relative_source_filenames }
-
-        describe 'yielded arguments' do
-          specify('should be the expected source filenames') {
-            is_expected.to match_array(expected_source_filenames)
-          }
-        end
-      end
-    end
-  end
-end

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