autoloaded 2.1.1 → 2.4.0

data/spec/autoloaded/autoloader_spec.rb

@@ -1,469 +0,0 @@
-RSpec.describe Autoloaded::Autoloader do
-  subject(:autoloader) { autoloader_class.new host_binding }
-
-  before :each do
-    allow(specifications_class).to receive(:new).and_return(specifications)
-    allow(inflector_class).to receive(:to_constant_name).
-                              and_return(:FromInflection1,
-                                         :FromInflection2,
-                                         :FromInflection3,
-                                         :FromInflection4)
-  end
-
-  let(:autoloader_class) { described_class }
-
-  let(:host_binding) { self.class.class_eval 'binding', __FILE__, __LINE__ }
-
-  let(:directory_class) { Autoloaded::LoadPathedDirectory }
-
-  let(:specifications) { specifications_class.new }
-
-  let(:specifications_class) { Autoloaded::Specifications }
-
-  let(:specification_class) { Autoloaded::Specification }
-
-  let(:inflector_class) { Autoloaded::Inflection }
-
-  describe '.new' do
-    describe 'with nil argument' do
-      specify {
-        expect { autoloader_class.new nil }.to raise_error(ArgumentError,
-                                                           "can't be nil")
-      }
-    end
-  end
-
-  describe '#from' do
-    subject(:from) { autoloader.from }
-
-    describe 'has expected default value' do
-      specify { is_expected.to eq(__FILE__.gsub(/\.rb$/, '')) }
-    end
-
-    describe 'rejects relative path argument' do
-      specify {
-        expect {
-          autoloader.from 'a/relative/path'
-        }.to raise_error(ArgumentError, "can't be relative")
-      }
-    end
-
-    describe 'operates as attribute reader and writer' do
-      specify {
-        autoloader.from '/an/absolute/path'
-        is_expected.to eq('/an/absolute/path')
-      }
-    end
-  end
-
-  describe '#except' do
-    specify("delegates to #{Autoloaded::Specifications.name}#except") {
-      expect(specifications.except).to be_empty
-      autoloader.except 'foo'
-      expect(specifications.except).to contain_exactly(specification_class.new('foo'))
-    }
-
-    describe 'where #only is specified' do
-      before :each do
-        autoloader.only :Foo
-      end
-
-      specify {
-        expect { autoloader.except :Bar }.to raise_error(RuntimeError,
-                                                         "can't specify `except' when `only' is already specified")
-      }
-    end
-  end
-
-  describe '#only' do
-    specify("delegates to #{Autoloaded::Specifications.name}#only") {
-      expect(specifications.only).to be_empty
-      autoloader.only 'foo'
-      expect(specifications.only).to contain_exactly(specification_class.new('foo'))
-    }
-
-    describe 'where #except is specified' do
-      before :each do
-        autoloader.except :Foo
-      end
-
-      specify {
-        expect { autoloader.only :Bar }.to raise_error(RuntimeError,
-                                                       "can't specify `only' when `except' is already specified")
-      }
-    end
-  end
-
-  describe '#with' do
-    specify("delegates to #{Autoloaded::Specifications.name}#with") {
-      expect(specifications.with).to be_empty
-      autoloader.with 'foo'
-      expect(specifications.with).to contain_exactly(specification_class.new('foo'))
-    }
-  end
-
-  describe '#autoload!' do
-    before :each do
-      allow_any_instance_of(directory_class).to receive(:closest_ruby_load_path).
-                                                and_return('/foo')
-      allow(directory_class).to receive(:new).and_return(directory)
-      allow(directory).to receive(:each_source_filename)
-    end
-
-    let(:directory) { directory_class.new '/foo' }
-
-    describe 'where #from is' do
-      describe 'not specified' do
-        describe "initializes #{Autoloaded::LoadPathedDirectory.name} with computed value" do
-          specify {
-            expect(directory_class).to receive(:new).
-                                       with(__FILE__.gsub(/\.rb$/, '')).
-                                       and_return(directory)
-            autoloader.autoload!
-          }
-        end
-      end
-
-      describe 'specified' do
-        before :each do
-          autoloader.from directory.path
-          allow(specifications).to receive(:except).
-                                   and_return(except_specifications)
-          allow(specifications).to receive(:only).
-                                   and_return(only_specifications)
-          allow(specifications).to receive(:with).
-                                   and_return(with_specifications)
-        end
-
-        let(:except_specifications) { [] }
-
-        let(:except_specification) { specification_class.new }
-
-        let(:only_specifications) { [] }
-
-        let(:only_specification) { specification_class.new }
-
-        let(:with_specifications) { [] }
-
-        let(:with_specification) { specification_class.new }
-
-        describe 'where no source files are found' do
-          specify {
-            expect(Kernel).not_to receive(:eval)
-            autoloader.autoload!
-          }
-
-          specify { expect(autoloader.autoload!).to be_empty }
-        end
-
-        describe 'where a source file is found' do
-          before :each do
-            allow(directory).to receive(:each_source_filename).
-                                and_yield('from_each_source_filename')
-          end
-
-          describe 'and no specifications are provided' do
-            specify {
-              expect(Kernel).to receive(:eval).
-                                with('autoload? :FromInflection1',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('constants.include? :FromInflection1',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('autoload :FromInflection1, "from_each_source_filename"',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              autoloader.autoload!
-            }
-
-            specify {
-              expect(autoloader.autoload!).to eq([[:FromInflection1,
-                                                   'from_each_source_filename']])
-            }
-          end
-
-          describe "and a `with' specification is provided" do
-            before :each do
-              allow(with_specification).to receive(:match).and_return(:FromWith)
-            end
-
-            let(:with_specifications) { [with_specification] }
-
-            specify {
-              expect(Kernel).to receive(:eval).
-                                with('autoload? :FromWith',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('constants.include? :FromWith',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('autoload :FromWith, "from_each_source_filename"',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric))
-                                     host_binding).
-                                ordered
-              autoloader.autoload!
-            }
-
-            specify {
-              expect(autoloader.autoload!).to eq([[:FromWith,
-                                                   'from_each_source_filename']])
-            }
-          end
-
-          describe "and an `only' specification is provided" do
-            before :each do
-              allow(only_specification).to receive(:match).and_return(:FromOnly)
-            end
-
-            let(:only_specifications) { [only_specification] }
-
-            specify {
-              expect(Kernel).to receive(:eval).
-                                with('autoload? :FromOnly',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('constants.include? :FromOnly',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('autoload :FromOnly, "from_each_source_filename"',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              autoloader.autoload!
-            }
-
-            specify { expect(autoloader.autoload!).to eq([[:FromOnly,
-                                                           'from_each_source_filename']]) }
-          end
-
-          describe "and both `with' and `only' specifications are provided" do
-            before :each do
-              allow(with_specification).to receive(:match).and_return(:FromWith)
-              allow(only_specification).to receive(:match).and_return(:FromOnly)
-            end
-
-            let(:with_specifications) { [with_specification] }
-
-            let(:only_specifications) { [only_specification] }
-
-            specify {
-              expect(Kernel).to receive(:eval).
-                                with('autoload? :FromWith',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('constants.include? :FromWith',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('autoload :FromWith, "from_each_source_filename"',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              autoloader.autoload!
-            }
-
-            specify { expect(autoloader.autoload!).to eq([[:FromWith,
-                                                           'from_each_source_filename']]) }
-          end
-        end
-
-        describe 'where multiple source files are found' do
-          before :each do
-            allow(directory).to receive(:each_source_filename).
-                                and_yield('from_each_source_filename1').
-                                and_yield('from_each_source_filename2').
-                                and_yield('from_each_source_filename3')
-          end
-
-          describe 'and no specifications are provided' do
-            specify {
-              expect(Kernel).to receive(:eval).
-                                with('autoload? :FromInflection1',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('constants.include? :FromInflection1',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('autoload :FromInflection1, "from_each_source_filename1"',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('autoload? :FromInflection2',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('constants.include? :FromInflection2',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('autoload :FromInflection2, "from_each_source_filename2"',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('autoload? :FromInflection3',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('constants.include? :FromInflection3',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('autoload :FromInflection3, "from_each_source_filename3"',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              autoloader.autoload!
-            }
-
-            specify {
-              expect(autoloader.autoload!).to eq([[:FromInflection1,
-                                                   'from_each_source_filename1'],
-                                                  [:FromInflection2,
-                                                   'from_each_source_filename2'],
-                                                  [:FromInflection3,
-                                                   'from_each_source_filename3']])
-            }
-          end
-
-          describe "and a matching `except' specification is provided" do
-            before :each do
-              allow(except_specification).to receive(:match).
-                                             with('from_each_source_filename1').
-                                             and_return(nil)
-              allow(except_specification).to receive(:match).
-                                             with('from_each_source_filename2').
-                                             and_return(:FromExcept)
-              allow(except_specification).to receive(:match).
-                                             with('from_each_source_filename3').
-                                             and_return(nil)
-            end
-
-            let(:except_specifications) { [except_specification] }
-
-            specify {
-              expect(Kernel).to receive(:eval).
-                                with('autoload? :FromInflection1',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('constants.include? :FromInflection1',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('autoload :FromInflection1, "from_each_source_filename1"',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('autoload? :FromInflection2',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('constants.include? :FromInflection2',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              expect(Kernel).to receive(:eval).
-                                with('autoload :FromInflection2, "from_each_source_filename3"',
-                                #      host_binding,
-                                #      kind_of(String),
-                                #      kind_of(Numeric)).
-                                     host_binding).
-                                ordered
-              autoloader.autoload!
-            }
-
-            specify {
-              expect(autoloader.autoload!).to eq([[:FromInflection1,
-                                                   'from_each_source_filename1'],
-                                                  [:FromInflection2,
-                                                   'from_each_source_filename3']])
-            }
-          end
-        end
-      end
-    end
-  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