naught 0.0.2 → 0.0.3

data/lib/naught/null_class_builder/commands/predicates_return.rb

@@ -0,0 +1,47 @@
+require 'naught/null_class_builder/command'
+
+module Naught::NullClassBuilder::Commands
+  class PredicatesReturn < Naught::NullClassBuilder::Command
+    def initialize(builder, return_value)
+      super(builder)
+      @predicate_return_value = return_value
+    end
+
+    def call
+      defer do |subject|
+        define_method_missing(subject)
+        define_predicate_methods(subject)
+      end
+    end
+
+    private
+
+    def define_method_missing(subject)
+      subject.module_exec(@predicate_return_value) do |return_value|
+        if subject.method_defined?(:method_missing)
+          original_method_missing = instance_method(:method_missing)
+          define_method(:method_missing) do
+            |method_name, *args, &block|
+            if method_name.to_s.end_with?('?')
+              return_value
+            else
+              original_method_missing.bind(self).call(method_name, *args, &block)
+            end
+          end
+        end
+      end
+    end
+
+    def define_predicate_methods(subject)
+      subject.module_exec(@predicate_return_value) do |return_value|
+        instance_methods.each do |method_name|
+          if method_name.to_s.end_with?('?')
+            define_method(method_name) do |*|
+              return_value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/naught/null_class_builder/commands/singleton.rb

@@ -0,0 +1,24 @@
+require 'naught/null_class_builder/command'
+
+module Naught::NullClassBuilder::Commands
+  class Singleton < Naught::NullClassBuilder::Command
+    def call
+      defer(class: true) do |subject|
+        require 'singleton'
+        subject.module_eval do
+          include ::Singleton
+
+          def self.get(*)
+            instance
+          end
+
+          %w(dup clone).each do |method_name|
+            define_method method_name do
+              self
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/naught/null_class_builder/commands/traceable.rb

@@ -0,0 +1,19 @@
+require 'naught/null_class_builder/command'
+
+module Naught::NullClassBuilder::Commands
+  class Traceable < Naught::NullClassBuilder::Command
+    def call
+      defer do |subject|
+        subject.module_eval do
+          attr_reader :__file__, :__line__
+
+          def initialize(options={})
+            backtrace = options.fetch(:caller) { Kernel.caller(4) }
+            @__file__, line, _ = backtrace[0].split(':')
+            @__line__ = line.to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/naught/null_class_builder/conversions_module.rb

@@ -0,0 +1,57 @@
+module Naught
+  class ConversionsModule < Module
+    attr_reader :null_class
+    attr_reader :null_equivs
+
+    def initialize(null_class, null_equivs)
+      @null_class  = null_class
+      @null_equivs = null_equivs
+      mod          = self
+      super() do
+        %w[Null Maybe Just Actual].each do |method_name|
+          define_method(method_name, &mod.method(method_name))
+        end
+      end
+    end
+
+    def Null(object=:nothing_passed)
+      case object
+      when NullObjectTag then object
+      when :nothing_passed, *null_equivs
+        null_class.get(caller: caller(1))
+      else raise ArgumentError, "#{object.inspect} is not null!"
+      end
+    end
+
+    def Maybe(object=nil, &block)
+      object = block ? block.call : object
+      case object
+      when NullObjectTag then object
+      when *null_equivs
+        null_class.get(caller: caller(1))
+      else
+        object
+      end
+    end
+
+    def Just(object=nil, &block)
+      object = block ? block.call : object
+      case object
+      when NullObjectTag, *null_equivs
+        raise ArgumentError, "Null value: #{object.inspect}"
+      else
+        object
+      end
+    end
+
+    def Actual(object=nil, &block)
+      object = block ? block.call : object
+      case object
+      when NullObjectTag then nil
+      else
+        object
+      end
+    end
+
+  end
+end

data/lib/naught/version.rb

@@ -1,3 +1,3 @@
 module Naught
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/naught.gemspec

@@ -20,7 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec", "~> 2.14"
   spec.add_development_dependency "guard"
   spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "guard-bundler"
 end

data/spec/base_object_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe 'null object with a custom base class' do
+
+  subject(:null) { custom_base_null_class.new }
+
+  let(:custom_base_null_class) do
+    Naught.build do |b|
+      b.base_class = Object
+    end
+  end
+
+  it 'respond to base class methods' do
+    expect(null.methods).to be_a_kind_of(Array)
+  end
+
+  it 'respond to unknown methods' do
+    expect(null.foo).to be_nil
+  end
+
+  it 'exposes the default base class choice, for the curious' do
+    default_base_class = :not_set
+    Naught.build do |b|
+      default_base_class = b.base_class
+    end
+    expect(default_base_class).to eq(BasicObject)
+  end
+
+  describe 'singleton null object' do
+    subject(:null_instance) { custom_base_singleton_null_class.instance }
+
+    let(:custom_base_singleton_null_class) do
+      Naught.build do |b|
+        b.singleton
+        b.base_class = Object
+      end
+    end
+
+    it 'can be cloned' do
+      expect(null_instance.clone).to be(null_instance)
+    end
+
+    it 'can be duplicated' do
+      expect(null_instance.dup).to be(null_instance)
+    end
+  end
+end

data/spec/basic_null_object_spec.rb

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'black hole null object' do
+  subject(:null) { null_class.new }
+  let(:null_class) {
+    Naught.build do |b|
+      b.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/conversions_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper.rb'
+
+describe 'explicitly convertable null object' do
+  let(:null_class) {
+    Naught.build do |b|
+      b.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)
+    expect(null.to_c).to eq(Complex(0))
+    expect(null.to_r).to eq(Rational(0))
+    expect(null.to_h).to eq({})
+  end
+end

data/spec/functions/actual_spec.rb

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

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

@@ -0,0 +1,35 @@
+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, return 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 = Maybe(); line = __LINE__
+    expect(null.__line__).to eq(line)
+    expect(null.__file__).to eq(__FILE__)
+  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

@@ -0,0 +1,34 @@
+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, return 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 = Null(); line = __LINE__
+    expect(null.__line__).to eq(line)
+    expect(null.__file__).to eq(__FILE__)
+  end
+
+end

data/spec/implicit_conversions_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe 'implicitly convertable null object' do
+  subject(:null) { null_class.new }
+  let(:null_class) {
+    Naught.build do |b|
+      b.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(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 string' do
+    expect(null.to_str).to eq("")
+  end
+
+end

data/spec/mimic_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+require 'logger'
+
+describe 'null object mimicking a class' do
+  class User
+    def login; "bob"; end
+  end
+
+  module Authorizable
+    def authorized_for?(object); true; end
+  end
+
+  class LibraryPatron < User
+    include Authorizable
+
+    def member?; true; end
+    def name; "Bob"; end
+    def notify_of_overdue_books(titles); puts 'Notifying...'; end
+  end
+
+  subject(:null) { mimic_class.new }
+  let(:mimic_class) {
+    Naught.build do |b|
+      b.mimic LibraryPatron
+    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) {
+      Naught.build do |b|
+        b.mimic LibraryPatron, include_super: false
+      end
+    }
+
+    it 'excludes inherited methods' do
+      expect(null).to_not respond_to(:authorized_for?)
+      expect(null).to_not respond_to(:login)
+    end
+  end
+end
+
+describe 'using mimic with black_hole' do
+  subject(:null) { mimic_class.new }
+  let(:mimic_class) {
+    Naught.build do |b|
+      b.mimic Logger
+      b.black_hole
+    end
+  }
+
+  def self.it_behaves_like_a_black_hole_mimic
+    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_behaves_like_a_black_hole_mimic
+
+  describe '(reverse order)' do
+    let(:mimic_class) {
+      Naught.build do |b|
+        b.black_hole
+        b.mimic Logger
+      end
+    }
+
+    it_behaves_like_a_black_hole_mimic
+  end
+
+end
+
+describe 'mimicking a non-Object-derived class' do
+  class MinimalClass < BasicObject
+  end
+
+  subject(:null) { mimic_class.new }
+  let(:mimic_class) {
+    Naught.build do |b|
+      b.mimic MinimalClass
+    end
+  }
+
+  it 'generates a BasicObject-derived null class' do
+    expect(BasicObject).to be === null
+    expect(Object).not_to be === null
+  end
+end