naught 0.0.3 → 1.0.0

data/lib/naught/null_class_builder/command.rb

@@ -8,11 +8,11 @@ module Naught
       end
 
       def call
-        raise NotImplementedError,
-              "Method #call should be overriden in child classes"
+        fail NotImplementedError,
+             'Method #call should be overriden in child classes'
       end
 
-      def defer(options={}, &block)
+      def defer(options = {}, &block)
         @builder.defer(options, &block)
       end
     end

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

@@ -1,3 +1,4 @@
+require 'forwardable'
 require 'naught/null_class_builder/command'
 
 module Naught::NullClassBuilder::Commands
@@ -5,13 +6,8 @@ module Naught::NullClassBuilder::Commands
     def call
       defer do |subject|
         subject.module_eval do
-          def to_s; ""; end
-          def to_i; 0; end
-          def to_f; 0.0; end
-          def to_c; 0.to_c; end
-          def to_r; 0.to_r; end
-          def to_a; []; end
-          def to_h; {}; end
+          extend Forwardable
+          def_delegators :nil, :to_a, :to_c, :to_f, :to_h, :to_i, :to_r, :to_s
         end
       end
     end

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

@@ -5,8 +5,13 @@ module Naught::NullClassBuilder::Commands
     def call
       defer do |subject|
         subject.module_eval do
-          def to_ary; []; end
-          def to_str; ''; end
+          def to_ary
+            []
+          end
+
+          def to_str
+            ''
+          end
         end
       end
     end

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

@@ -1,9 +1,8 @@
 module Naught::NullClassBuilder::Commands
   class Impersonate < Naught::NullClassBuilder::Commands::Mimic
-    def initialize(builder, class_to_impersonate, options={})
+    def initialize(builder, class_to_impersonate, options = {})
       super
-
-      builder.base_class   = class_to_impersonate
+      builder.base_class = class_to_impersonate
     end
   end
 end

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

@@ -1,17 +1,18 @@
+require 'naught/basic_object'
 require 'naught/null_class_builder/command'
 
 module Naught::NullClassBuilder::Commands
   class Mimic < Naught::NullClassBuilder::Command
     attr_reader :class_to_mimic, :include_super
 
-    def initialize(builder, class_to_mimic, options={})
+    def initialize(builder, class_to_mimic, options = {})
       super(builder)
 
       @class_to_mimic = class_to_mimic
       @include_super = options.fetch(:include_super) { true }
 
       builder.base_class   = root_class_of(class_to_mimic)
-      builder.inspect_proc = -> { "<null:#{class_to_mimic}>" }
+      builder.inspect_proc = lambda { "<null:#{class_to_mimic}>" }
       builder.interface_defined = true
     end
 
@@ -26,11 +27,7 @@ module Naught::NullClassBuilder::Commands
     private
 
     def root_class_of(klass)
-      if klass.ancestors.include?(Object)
-        Object
-      else
-        BasicObject
-      end
+      klass.ancestors.include?(Object) ? Object : Naught::BasicObject
     end
 
     def methods_to_stub

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

@@ -4,8 +4,7 @@ module Naught
   class NullClassBuilder
     module Commands
       class Pebble < ::Naught::NullClassBuilder::Command
-
-        def initialize(builder, output=$stdout)
+        def initialize(builder, output = $stdout)
           @builder = builder
           @output = output
         end
@@ -15,18 +14,17 @@ module Naught
             subject.module_exec(@output) do |output|
 
               define_method(:method_missing) do |method_name, *args, &block|
-                pretty_args = args.map(&:inspect).join(", ").gsub("\"", "'")
+                pretty_args = args.collect(&:inspect).join(', ').gsub("\"", "'")
                 output.puts "#{method_name}(#{pretty_args}) from #{parse_caller}"
                 self
               end
 
-              private
-
               def parse_caller
                 caller = Kernel.caller(2).first
                 method_name = caller.match(/\`([\w\s]+(\(\d+\s\w+\))?[\w\s]*)/)
                 method_name ? method_name[1] : caller
               end
+              private :parse_caller
             end
           end
         end

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

@@ -20,8 +20,7 @@ module Naught::NullClassBuilder::Commands
       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|
+          define_method(:method_missing) do |method_name, *args, &block|
             if method_name.to_s.end_with?('?')
               return_value
             else

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

@@ -3,7 +3,7 @@ require 'naught/null_class_builder/command'
 module Naught::NullClassBuilder::Commands
   class Singleton < Naught::NullClassBuilder::Command
     def call
-      defer(class: true) do |subject|
+      defer(:class => true) do |subject|
         require 'singleton'
         subject.module_eval do
           include ::Singleton

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

@@ -7,8 +7,9 @@ module Naught::NullClassBuilder::Commands
         subject.module_eval do
           attr_reader :__file__, :__line__
 
-          def initialize(options={})
-            backtrace = options.fetch(:caller) { Kernel.caller(4) }
+          def initialize(options = {})
+            range = (RUBY_VERSION.to_f == 1.9 && RUBY_PLATFORM != 'java') ? 4 : 3
+            backtrace = options.fetch(:caller) { Kernel.caller(range) }
             @__file__, line, _ = backtrace[0].split(':')
             @__line__ = line.to_i
           end

data/lib/naught/version.rb

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

data/naught.gemspec

@@ -4,24 +4,19 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'naught/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "naught"
+  spec.name          = 'naught'
   spec.version       = Naught::VERSION
-  spec.authors       = ["Avdi Grimm"]
-  spec.email         = ["avdi@avdi.org"]
+  spec.authors       = ['Avdi Grimm']
+  spec.email         = ['avdi@avdi.org']
   spec.description   = %q{Naught is a toolkit for building Null Objects}
-  spec.summary       = %q{Naught is a toolkit for building Null Objects}
-  spec.homepage      = "https://github.com/avdi/naught"
-  spec.license       = "MIT"
+  spec.summary       = spec.description
+  spec.homepage      = 'https://github.com/avdi/naught'
+  spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~> 2.14"
-  spec.add_development_dependency "guard"
-  spec.add_development_dependency "guard-rspec"
-  spec.add_development_dependency "guard-bundler"
+  spec.add_development_dependency 'bundler', '~> 1.3'
 end

data/spec/base_object_spec.rb

@@ -11,7 +11,7 @@ describe 'null object with a custom base class' do
   end
 
   it 'respond to base class methods' do
-    expect(null.methods).to be_a_kind_of(Array)
+    expect(null.methods).to be_an Array
   end
 
   it 'respond to unknown methods' do
@@ -23,7 +23,7 @@ describe 'null object with a custom base class' do
     Naught.build do |b|
       default_base_class = b.base_class
     end
-    expect(default_base_class).to eq(BasicObject)
+    expect(default_base_class).to eq(Naught::BasicObject)
   end
 
   describe 'singleton null object' do

data/spec/basic_null_object_spec.rb

@@ -11,7 +11,7 @@ describe 'basic null object' do
   end
 
   it 'accepts any arguments for any messages' do
-    null.foobaz(1,2,3)
+    null.foobaz(1, 2, 3)
   end
 
   it 'reports that it responds to any message' do
@@ -21,7 +21,7 @@ describe 'basic null object' do
   end
 
   it 'can be inspected' do
-    expect(null.inspect).to eq("<null>")
+    expect(null.inspect).to eq('<null>')
   end
 
   it 'knows its own class' do
@@ -32,4 +32,4 @@ describe 'basic null object' do
     expect(null_class.get.class).to be(null_class)
   end
 
-end
+end

data/spec/blackhole_spec.rb

@@ -2,15 +2,15 @@ require 'spec_helper'
 
 describe 'black hole null object' do
   subject(:null) { null_class.new }
-  let(:null_class) {
+  let(:null_class) do
     Naught.build do |b|
       b.black_hole
     end
-  }
+  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)
+    expect(null << 'bar').to be(null)
   end
-end
+end

data/spec/explicit_conversions_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper.rb'
+
+describe 'explicitly convertable null object' do
+  let(:null_class) do
+    Naught.build do |b|
+      b.define_explicit_conversions
+    end
+  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

@@ -10,13 +10,13 @@ describe 'Actual()' do
 
   specify 'given anything else, returns the input unchanged' do
     expect(Actual(false)).to be(false)
-    str = "hello"
+    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")
+    expect(Actual { ConvertableNull.new }).to be_nil
+    expect(Actual { 'foo' }).to eq('foo')
   end
-end
+end

data/spec/functions/just_spec.rb

@@ -5,18 +5,18 @@ describe 'Just()' do
 
   specify 'passes non-nullish values through' do
     expect(Just(false)).to be(false)
-    str = "hello"
+    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)
+    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")
+    expect { Just { nil }.class }.to raise_error(ArgumentError)
+    expect(Just { 'foo' }).to eq('foo')
   end
-end
+end

data/spec/functions/maybe_spec.rb

@@ -13,23 +13,23 @@ describe 'Maybe()' do
   end
 
   specify 'given anything in null_equivalents, return a null object' do
-    expect(Maybe("").class).to be(ConvertableNull)
+    expect(Maybe('').class).to be(ConvertableNull)
   end
 
   specify 'given anything else, returns the input unchanged' do
     expect(Maybe(false)).to be(false)
-    str = "hello"
+    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)
+    null, line = Maybe(), __LINE__
     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")
+    expect(Maybe { nil }.class).to eq(ConvertableNull)
+    expect(Maybe { 'foo' }).to eq('foo')
   end
-end
+end

data/spec/functions/null_spec.rb

@@ -17,18 +17,18 @@ describe 'Null()' do
   end
 
   specify 'given anything in null_equivalents, return a null object' do
-    expect(Null("").class).to be(ConvertableNull)
+    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)
+    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)
+    null, line = Null(), __LINE__
     expect(null.__file__).to eq(__FILE__)
+    expect(null.__line__).to eq(line)
   end
 
-end
+end

data/spec/implicit_conversions_spec.rb

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

data/spec/mimic_spec.rb

@@ -3,27 +3,39 @@ require 'logger'
 
 describe 'null object mimicking a class' do
   class User
-    def login; "bob"; end
+    def login
+      'bob'
+    end
   end
 
   module Authorizable
-    def authorized_for?(object); true; end
+    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
+    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) {
+  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
@@ -31,7 +43,7 @@ describe 'null object mimicking a class' do
   end
 
   it 'does not respond to methods not defined on the target class' do
-    expect{null.foobar}.to raise_error(NoMethodError)
+    expect { null.foobar }.to raise_error(NoMethodError)
   end
 
   it 'reports which messages it does and does not respond to' do
@@ -41,7 +53,7 @@ describe 'null object mimicking a class' do
     expect(null).not_to respond_to(:foobar)
   end
   it 'has an informative inspect string' do
-    expect(null.inspect).to eq("<null:LibraryPatron>")
+    expect(null.inspect).to eq('<null:LibraryPatron>')
   end
 
   it 'excludes Object methods from being mimicked' do
@@ -55,11 +67,11 @@ describe 'null object mimicking a class' do
   end
 
   describe 'with include_super: false' do
-    let(:mimic_class) {
+    let(:mimic_class) do
       Naught.build do |b|
-        b.mimic LibraryPatron, include_super: false
+        b.mimic LibraryPatron, :include_super => false
       end
-    }
+    end
 
     it 'excludes inherited methods' do
       expect(null).to_not respond_to(:authorized_for?)
@@ -70,53 +82,36 @@ end
 
 describe 'using mimic with black_hole' do
   subject(:null) { mimic_class.new }
-  let(:mimic_class) {
+  let(:mimic_class) do
     Naught.build do |b|
       b.mimic Logger
       b.black_hole
     end
-  }
+  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)
+      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)
+      expect { null.foobar }.to raise_error(NoMethodError)
     end
   end
 
   it_behaves_like_a_black_hole_mimic
 
   describe '(reverse order)' do
-    let(:mimic_class) {
+    let(:mimic_class) do
       Naught.build do |b|
         b.black_hole
         b.mimic Logger
       end
-    }
+    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