naught 0.0.1

data/spec/naught_spec.rb

@@ -0,0 +1,429 @@
+require 'spec_helper'
+require 'naught'
+
+module Naught
+  describe 'basic null object' do
+    subject(:null) { null_class.new }
+    let(:null_class) {
+      Naught.build
+    }
+    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
+  describe 'explicitly convertable null object' do
+    subject(:null) { null_class.new }
+    let(:null_class) { 
+      Naught.build do |b|
+        b.define_explicit_conversions
+      end
+    }
+  
+    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
+  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
+  describe 'singleton null object' do
+    subject(:null_class) { 
+      Naught.build do |b|
+        b.singleton
+      end
+    }
+  
+    it 'does not respond to .new' do
+      expect{ null_class.new }.to raise_error
+    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_nil
+    end
+    
+    it 'can be duplicated' do
+      null = null_class.instance
+      expect(null.dup).to be_nil
+    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
+  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
+  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 Bob his books are overdue..."
+      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:Naught::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
+    require 'logger'
+    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 'null object impersonating another type' do
+    class Point
+      def x; 23; end
+      def y; 42; end
+    end
+  
+    subject(:null) { impersonation_class.new }
+    let(:impersonation_class) {
+      Naught.build do |b|
+        b.impersonate Point
+      end
+    }
+  
+    it 'matches the impersonated type' do
+      expect(Point).to be === null
+    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) {
+      null_object_and_line.first
+    }
+    let(:null_object_and_line) {
+      obj = trace_null_class.new; line = __LINE__;
+      [obj, line]
+    }
+    let(:instantiation_line) { null_object_and_line.last }
+    let(:trace_null_class) {
+      Naught.build do |b|
+        b.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 = make_null; line = __LINE__
+      expect(obj.__line__).to eq(line)
+    end
+  end
+  describe 'customized null object' do
+    subject(:custom_null) { custom_null_class.new }
+    let(:custom_null_class) {
+      Naught.build do |b|
+        b.define_explicit_conversions
+        def to_path
+          "/dev/null"
+        end
+        def to_s
+          "NOTHING TO SEE HERE"
+        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].map(&:name)).to eq([
+          'Naught::TestNull', 
+          'Naught::TestNull::Customizations', 
+          'Naught::TestNull::GeneratedMethods'
+        ])
+    end
+  end
+  ConvertableNull = Naught.build do |b|
+    b.null_equivalents << ""
+    b.traceable
+  end
+  
+  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
+  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
+  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
+  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
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: naught
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Avdi Grimm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Naught is a toolkit for building Null Objects
+email:
+- avdi@avdi.org
+executables:
+- autospec
+- coderay
+- guard
+- htmldiff
+- ldiff
+- pry
+- rake
+- rspec
+- thor
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.org
+- Rakefile
+- bin/autospec
+- bin/coderay
+- bin/guard
+- bin/htmldiff
+- bin/ldiff
+- bin/pry
+- bin/rake
+- bin/rspec
+- bin/thor
+- lib/naught.rb
+- lib/naught/null_class_builder.rb
+- lib/naught/null_class_builder/commands/define_explicit_conversions.rb
+- lib/naught/version.rb
+- naught.gemspec
+- spec/naught_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/avdi/naught
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Naught is a toolkit for building Null Objects
+test_files:
+- spec/naught_spec.rb
+- spec/spec_helper.rb
+has_rdoc: