naught 1.1.0 → 2.0.0

data/spec/basic_null_object_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe 'basic null object' do
-  let(:null_class) { Naught.build }
-  subject(:null) { null_class.new }
-
-  it 'responds to arbitrary messages and returns nil' do
-    expect(null.info).to be_nil
-    expect(null.foobaz).to be_nil
-    expect(null.to_s).to be_nil
-  end
-
-  it 'accepts any arguments for any messages' do
-    null.foobaz(1, 2, 3)
-  end
-
-  it 'reports that it responds to any message' do
-    expect(null).to respond_to(:info)
-    expect(null).to respond_to(:foobaz)
-    expect(null).to respond_to(:to_s)
-  end
-
-  it 'can be inspected' do
-    expect(null.inspect).to eq('<null>')
-  end
-
-  it 'knows its own class' do
-    expect(null.class).to eq(null_class)
-  end
-
-  it 'aliases .new to .get' do
-    expect(null_class.get.class).to be(null_class)
-  end
-end

data/spec/blackhole_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe 'black hole null object' do
-  subject(:null) { null_class.new }
-  let(:null_class) do
-    Naught.build(&:black_hole)
-  end
-
-  it 'returns self from arbitray method calls' do
-    expect(null.info).to be(null)
-    expect(null.foobaz).to be(null)
-    expect(null << 'bar').to be(null)
-  end
-end

data/spec/explicit_conversions_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper.rb'
-
-describe 'explicitly convertable null object' do
-  let(:null_class) do
-    Naught.build(&:define_explicit_conversions)
-  end
-  subject(:null) { null_class.new }
-
-  it 'defines common explicit conversions to return zero values' do
-    expect(null.to_s).to eq('')
-    expect(null.to_a).to eq([])
-    expect(null.to_i).to eq(0)
-    expect(null.to_f).to eq(0.0)
-    if RUBY_VERSION >= '2.0'
-      expect(null.to_h).to eq({})
-    elsif RUBY_VERSION >= '1.9'
-      expect(null.to_c).to eq(Complex(0))
-      expect(null.to_r).to eq(Rational(0))
-    end
-  end
-end

data/spec/functions/actual_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe 'Actual()' do
-  include ConvertableNull::Conversions
-
-  specify 'given a null object, returns nil' do
-    null = ConvertableNull.get
-    expect(Actual(null)).to be_nil
-  end
-
-  specify 'given anything else, returns the input unchanged' do
-    expect(Actual(false)).to be(false)
-    str = 'hello'
-    expect(Actual(str)).to be(str)
-    expect(Actual(nil)).to be_nil
-  end
-
-  it 'also works with blocks' do
-    expect(Actual { ConvertableNull.new }).to be_nil
-    expect(Actual { 'foo' }).to eq('foo')
-  end
-end

data/spec/functions/just_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe 'Just()' do
-  include ConvertableNull::Conversions
-
-  specify 'passes non-nullish values through' do
-    expect(Just(false)).to be(false)
-    str = 'hello'
-    expect(Just(str)).to be(str)
-  end
-
-  specify 'rejects nullish values' do
-    expect { Just(nil) }.to raise_error(ArgumentError)
-    expect { Just('') }.to raise_error(ArgumentError)
-    expect { Just(ConvertableNull.get) }.to raise_error(ArgumentError)
-  end
-
-  it 'also works with blocks' do
-    expect { Just { nil }.class }.to raise_error(ArgumentError)
-    expect(Just { 'foo' }).to eq('foo')
-  end
-end

data/spec/functions/maybe_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe 'Maybe()' do
-  include ConvertableNull::Conversions
-
-  specify 'given nil, returns a null object' do
-    expect(Maybe(nil).class).to be(ConvertableNull)
-  end
-
-  specify 'given a null object, returns the same null object' do
-    null = ConvertableNull.get
-    expect(Maybe(null)).to be(null)
-  end
-
-  specify 'given anything in null_equivalents, returns a null object' do
-    expect(Maybe('').class).to be(ConvertableNull)
-  end
-
-  specify 'given anything else, returns the input unchanged' do
-    expect(Maybe(false)).to be(false)
-    str = 'hello'
-    expect(Maybe(str)).to be(str)
-  end
-
-  it 'generates null objects with useful trace info' do
-    null, line = Maybe(), __LINE__ # rubocop:disable ParallelAssignment
-    expect(null.__file__).to eq(__FILE__)
-    expect(null.__line__).to eq(line)
-  end
-
-  it 'also works with blocks' do
-    expect(Maybe { nil }.class).to eq(ConvertableNull)
-    expect(Maybe { 'foo' }).to eq('foo')
-  end
-end

data/spec/functions/null_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe 'Null()' do
-  include ConvertableNull::Conversions
-
-  specify 'given no input, returns a null object' do
-    expect(Null().class).to be(ConvertableNull)
-  end
-
-  specify 'given nil, returns a null object' do
-    expect(Null(nil).class).to be(ConvertableNull)
-  end
-
-  specify 'given a null object, returns the same null object' do
-    null = ConvertableNull.get
-    expect(Null(null)).to be(null)
-  end
-
-  specify 'given anything in null_equivalents, returns a null object' do
-    expect(Null('').class).to be(ConvertableNull)
-  end
-
-  specify 'given anything else, raises an ArgumentError' do
-    expect { Null(false) }.to raise_error(ArgumentError)
-    expect { Null('hello') }.to raise_error(ArgumentError)
-  end
-
-  it 'generates null objects with useful trace info' do
-    null, line = Null(), __LINE__ # rubocop:disable ParallelAssignment
-    expect(null.__file__).to eq(__FILE__)
-    expect(null.__line__).to eq(line)
-  end
-end

data/spec/implicit_conversions_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe 'implicitly convertable null object' do
-  subject(:null) { null_class.new }
-  let(:null_class) do
-    Naught.build(&:define_implicit_conversions)
-  end
-  it 'implicitly splats the same way an empty array does' do
-    a, b = null
-    expect(a).to be_nil
-    expect(b).to be_nil
-  end
-  it 'is implicitly convertable to String' do
-    expect(instance_eval(null)).to be_nil
-  end
-  it 'implicitly converts to an empty array' do
-    expect(null.to_ary).to eq([])
-  end
-  it 'implicitly converts to an empty hash' do
-    expect(null.to_hash).to eq({})
-  end
-  it 'implicitly converts to zero' do
-    expect(null.to_int).to eq(0)
-  end
-  it 'implicitly converts to an empty string' do
-    expect(null.to_str).to eq('')
-  end
-end

data/spec/mimic_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper'
-require 'logger'
-
-describe 'null object mimicking a class' do
-  class User
-    attr_reader :login
-  end
-
-  module Authorizable
-    def authorized_for?(_); end
-  end
-
-  class LibraryPatron < User
-    include Authorizable
-    attr_reader :name
-
-    def member?; end
-
-    def notify_of_overdue_books(_); end
-  end
-
-  subject(:null) { mimic_class.new }
-  let(:mimic_class) do
-    Naught.build do |b|
-      b.mimic LibraryPatron
-    end
-  end
-  it 'responds to all methods defined on the target class' do
-    expect(null.member?).to be_nil
-    expect(null.name).to be_nil
-    expect(null.notify_of_overdue_books(['The Grapes of Wrath'])).to be_nil
-  end
-
-  it 'does not respond to methods not defined on the target class' do
-    expect { null.foobar }.to raise_error(NoMethodError)
-  end
-
-  it 'reports which messages it does and does not respond to' do
-    expect(null).to respond_to(:member?)
-    expect(null).to respond_to(:name)
-    expect(null).to respond_to(:notify_of_overdue_books)
-    expect(null).not_to respond_to(:foobar)
-  end
-  it 'has an informative inspect string' do
-    expect(null.inspect).to eq('<null:LibraryPatron>')
-  end
-
-  it 'excludes Object methods from being mimicked' do
-    expect(null.object_id).not_to be_nil
-    expect(null.hash).not_to be_nil
-  end
-
-  it 'includes inherited methods' do
-    expect(null.authorized_for?('something')).to be_nil
-    expect(null.login).to be_nil
-  end
-
-  describe 'with include_super: false' do
-    let(:mimic_class) do
-      Naught.build do |b|
-        b.mimic LibraryPatron, :include_super => false
-      end
-    end
-
-    it 'excludes inherited methods' do
-      expect(null).to_not respond_to(:authorized_for?)
-      expect(null).to_not respond_to(:login)
-    end
-  end
-
-  describe 'with an instance as example' do
-    let(:mimic_class) do
-      milton = LibraryPatron.new
-      def milton.stapler; end
-      Naught.build do |b|
-        b.mimic :example => milton
-      end
-    end
-
-    it 'responds to method defined only on the example instance' do
-      expect(null).to respond_to(:stapler)
-    end
-
-    it 'responds to method defined on the class of the instance' do
-      expect(null).to respond_to(:member?)
-    end
-  end
-end
-
-describe 'using mimic with black_hole' do
-  subject(:null) { mimic_class.new }
-  let(:mimic_class) do
-    Naught.build do |b|
-      b.mimic Logger
-      b.black_hole
-    end
-  end
-
-  shared_examples_for 'a black hole mimic' do
-    it 'returns self from mimicked methods' do
-      expect(null.info).to equal(null)
-      expect(null.error).to equal(null)
-      expect(null << 'test').to equal(null)
-    end
-
-    it 'does not respond to methods not defined on the target class' do
-      expect { null.foobar }.to raise_error(NoMethodError)
-    end
-  end
-
-  it_should_behave_like 'a black hole mimic'
-
-  describe '(reverse order)' do
-    let(:mimic_class) do
-      Naught.build do |b|
-        b.black_hole
-        b.mimic Logger
-      end
-    end
-
-    it_should_behave_like 'a black hole mimic'
-  end
-end

data/spec/naught/null_object_builder/command_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-module Naught
-  describe NullClassBuilder::Command do
-    it 'is abstract' do
-      command = NullClassBuilder::Command.new(nil)
-      expect { command.call }.to raise_error(NotImplementedError)
-    end
-  end
-end

data/spec/naught/null_object_builder_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-module Naught
-  class NullClassBuilder
-    module Commands
-      class TestCommand
-      end
-    end
-  end
-
-  describe NullClassBuilder do
-    subject(:builder) { NullClassBuilder.new }
-    it 'responds to commands defined in NullObjectBuilder::Commands' do
-      expect(builder).to respond_to(:test_command)
-    end
-
-    it 'translates method calls into command invocations including arguments' do
-      test_command = double
-      expect(NullClassBuilder::Commands::TestCommand).to receive(:new).
-        with(builder, 'foo', 42).
-        and_return(test_command)
-      expect(test_command).to receive(:call).and_return('COMMAND RESULT')
-      expect(builder.test_command('foo', 42)).to eq('COMMAND RESULT')
-    end
-
-    it 'handles missing non-command missing methods normally' do
-      expect(builder).not_to respond_to(:nonexistant_method)
-      expect { builder.nonexistent_method }.to raise_error(NoMethodError)
-    end
-  end
-end

data/spec/naught_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-
-describe 'null object impersonating another type' do
-  class Point
-    attr_reader :x, :y
-  end
-
-  subject(:null) { impersonation_class.new }
-  let(:impersonation_class) do
-    Naught.build do |b|
-      b.impersonate Point
-    end
-  end
-
-  it 'matches the impersonated type' do
-    expect(null).to be_a Point
-  end
-
-  it 'responds to methods from the impersonated type' do
-    expect(null.x).to be_nil
-    expect(null.y).to be_nil
-  end
-
-  it 'does not respond to unknown methods' do
-    expect { null.foo }.to raise_error(NoMethodError)
-  end
-end
-
-describe 'traceable null object' do
-  subject(:trace_null) do
-    null_object_and_line.first
-  end
-  let(:null_object_and_line) do
-    obj, line = trace_null_class.new, __LINE__ # rubocop:disable ParallelAssignment
-    [obj, line]
-  end
-  let(:instantiation_line) { null_object_and_line.last }
-  let(:trace_null_class) do
-    Naught.build(&:traceable)
-  end
-
-  it 'remembers the file it was instantiated from' do
-    expect(trace_null.__file__).to eq(__FILE__)
-  end
-
-  it 'remembers the line it was instantiated from' do
-    expect(trace_null.__line__).to eq(instantiation_line)
-  end
-
-  def make_null
-    trace_null_class.get(:caller => caller(1))
-  end
-
-  it 'can accept custom backtrace info' do
-    obj, line = make_null, __LINE__ # rubocop:disable ParallelAssignment
-    expect(obj.__line__).to eq(line)
-  end
-end
-
-describe 'customized null object' do
-  subject(:custom_null) { custom_null_class.new }
-  let(:custom_null_class) do
-    Naught.build do |b|
-      b.define_explicit_conversions
-      def to_path
-        '/dev/null'
-      end
-
-      def to_s
-        'NOTHING TO SEE HERE'
-      end
-    end
-  end
-
-  it 'responds to custom-defined methods' do
-    expect(custom_null.to_path).to eq('/dev/null')
-  end
-
-  it 'allows generated methods to be overridden' do
-    expect(custom_null.to_s).to eq('NOTHING TO SEE HERE')
-  end
-end
-TestNull = Naught.build
-
-describe 'a named null object class' do
-  it 'has named ancestor modules' do
-    expect(TestNull.ancestors[0..2].collect(&:name)).to eq([
-      'TestNull',
-      'TestNull::Customizations',
-      'TestNull::GeneratedMethods',
-    ])
-  end
-end

data/spec/pebble_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-require 'stringio'
-
-describe 'pebble null object' do
-  class Caller
-    def call_method(thing)
-      thing.info
-    end
-
-    def call_method_inside_block(thing)
-      2.times.each { thing.info }
-    end
-
-    def call_method_inside_nested_block(thing)
-      2.times.each { 2.times.each { thing.info } }
-    end
-  end
-
-  subject(:null) { null_class.new }
-  let(:null_class) do
-    output = test_output # getting local binding
-    Naught.build do |b|
-      b.pebble output
-    end
-  end
-
-  let(:test_output) { StringIO.new }
-
-  it 'prints the name of the method called' do
-    expect(test_output).to receive(:puts).with(/^info\(\)/)
-    null.info
-  end
-
-  it 'prints the arguments received' do
-    expect(test_output).to receive(:puts).with(/^info\(\'foo\', 5, \:sym\)/)
-    null.info('foo', 5, :sym)
-  end
-
-  it 'prints the name of the caller' do
-    expect(test_output).to receive(:puts).with(/from call_method$/)
-    Caller.new.call_method(null)
-  end
-
-  it 'returns self' do
-    expect(null.info).to be(null)
-  end
-
-  context 'when is called from a block' do
-    it 'prints the indication of a block',
-       :pending => jruby? || rubinius? || ruby_18? do
-      expect(test_output).to receive(:puts).twice.
-        with(/from block/)
-      Caller.new.call_method_inside_block(null)
-    end
-
-    it 'prints the name of the method that has the block' do
-      expect(test_output).to receive(:puts).twice.
-        with(/call_method_inside_block$/)
-      Caller.new.call_method_inside_block(null)
-    end
-  end
-
-  context 'when is called from many levels blocks' do
-    it 'prints the indication of blocks and its levels',
-       :pending => jruby? || rubinius? || ruby_18? do
-      expect(test_output).to receive(:puts).exactly(4).times.
-        with(/from block \(2 levels\)/)
-      Caller.new.call_method_inside_nested_block(null)
-    end
-
-    it 'prints the name of the method that has the block' do
-      expect(test_output).to receive(:puts).exactly(4).times.
-        with(/call_method_inside_nested_block$/)
-      Caller.new.call_method_inside_nested_block(null)
-    end
-  end
-end

data/spec/predicate_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-describe 'a null object with predicates_return(false)' do
-  subject(:null) { null_class.new }
-  let(:null_class) do
-    Naught.build do |config|
-      config.predicates_return false
-    end
-  end
-
-  it 'responds to predicate-style methods with false' do
-    expect(null.too_much_coffee?).to be(false)
-  end
-
-  it 'responds to other methods with nil' do
-    expect(null.foobar).to be(nil)
-  end
-
-  describe '(black hole)' do
-    let(:null_class) do
-      Naught.build do |config|
-        config.black_hole
-        config.predicates_return false
-      end
-    end
-
-    it 'responds to predicate-style methods with false' do
-      expect(null.too_much_coffee?).to be(false)
-    end
-
-    it 'responds to other methods with self' do
-      expect(null.foobar).to be(null)
-    end
-  end
-
-  describe '(black hole, reverse order config)' do
-    let(:null_class) do
-      Naught.build do |config|
-        config.predicates_return false
-        config.black_hole
-      end
-    end
-
-    it 'responds to predicate-style methods with false' do
-      expect(null.too_much_coffee?).to be(false)
-    end
-
-    it 'responds to other methods with self' do
-      expect(null.foobar).to be(null)
-    end
-  end
-
-  class Coffee
-    attr_reader :origin
-    def black?; end
-  end
-
-  describe '(mimic)' do
-    let(:null_class) do
-      Naught.build do |config|
-        config.mimic Coffee
-        config.predicates_return false
-      end
-    end
-
-    it 'responds to predicate-style methods with false' do
-      expect(null.black?).to be(false)
-    end
-
-    it 'responds to other methods with nil' do
-      expect(null.origin).to be(nil)
-    end
-
-    it 'does not respond to undefined methods' do
-      expect(null).not_to respond_to(:leaf_variety)
-      expect { null.leaf_variety }.to raise_error(NoMethodError)
-    end
-  end
-end

data/spec/singleton_null_object_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe 'singleton null object' do
-  subject(:null_class) do
-    Naught.build(&:singleton)
-  end
-
-  it 'does not respond to .new' do
-    expect { null_class.new }.to raise_error(NoMethodError)
-  end
-
-  it 'has only one instance' do
-    null1 = null_class.instance
-    null2 = null_class.instance
-    expect(null1).to be(null2)
-  end
-
-  it 'can be cloned' do
-    null = null_class.instance
-    expect(null.clone).to be(null)
-  end
-
-  it 'can be duplicated' do
-    null = null_class.instance
-    expect(null.dup).to be(null)
-  end
-  it 'aliases .instance to .get' do
-    expect(null_class.get).to be null_class.instance
-  end
-  it 'permits arbitrary arguments to be passed to .get' do
-    null_class.get(42, :foo => 'bar')
-  end
-end

data/spec/spec_helper.rb

@@ -1,15 +0,0 @@
-GEM_ROOT = File.expand_path('../../', __FILE__)
-$LOAD_PATH.unshift File.join(GEM_ROOT, 'lib')
-
-require 'simplecov'
-require 'coveralls'
-
-SimpleCov.formatters = [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
-
-SimpleCov.start do
-  add_filter '/spec/'
-  minimum_coverage(97.7)
-end
-
-require 'naught'
-Dir[File.join(GEM_ROOT, 'spec', 'support', '**/*.rb')].each { |f| require f }

data/spec/support/convertable_null.rb

@@ -1,4 +0,0 @@
-ConvertableNull = Naught.build do |b|
-  b.null_equivalents << ''
-  b.traceable
-end

data/spec/support/jruby.rb

@@ -1,3 +0,0 @@
-def jruby?
-  RUBY_PLATFORM == 'java'
-end