autoloaded 1.6.0 → 2.0.0

data/spec/autoloaded/inflection_spec.rb

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

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

@@ -0,0 +1,98 @@
+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) { [: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) { [{[: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', {[:Bar, :FromInflection2] => 'baz/qux'}] }
+
+    specify { expect(specification.match('quux')).to eq('baz/qux') }
+  end
+end

data/spec/autoloaded/specifications_spec.rb

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

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

data/spec/autoloaded/warning_spec.rb

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