naught 0.0.2 → 0.0.3

data/spec/pebble_spec.rb

@@ -0,0 +1,75 @@
+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) {
+    output = test_output # getting local binding
+    Naught.build do |b|
+      b.pebble output
+    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" 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(/in 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" 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(/in call_method_inside_nested_block$/)
+      Caller.new.call_method_inside_nested_block(null)
+    end
+  end
+end

data/spec/predicate_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe 'a null object with predicates_return(false)' do
+  subject(:null) { null_class.new }
+  let(:null_class) {
+    Naught.build do |config|
+      config.predicates_return false
+    end
+  }
+
+  it 'responds to predicate-style methods with false' do
+    expect(null.too_much_coffee?).to eq(false)
+  end
+
+  it 'responds to other methods with nil' do
+    expect(null.foobar).to eq(nil)
+  end
+
+  describe '(black hole)' do
+    let(:null_class) {
+      Naught.build do |config|
+        config.black_hole
+        config.predicates_return false
+      end
+    }
+
+    it 'responds to predicate-style methods with false' do
+      expect(null.too_much_coffee?).to eq(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) {
+      Naught.build do |config|
+        config.predicates_return false
+        config.black_hole
+      end
+    }
+
+    it 'responds to predicate-style methods with false' do
+      expect(null.too_much_coffee?).to eq(false)
+    end
+
+    it 'responds to other methods with self' do
+       expect(null.foobar).to be(null)
+    end
+  end
+
+
+  class Coffee
+    def black?; true; end
+    def origin; "Ethiopia"; end
+  end
+
+  describe '(mimic)' do
+    let(:null_class) {
+      Naught.build do |config|
+        config.mimic Coffee
+        config.predicates_return false
+      end
+    }
+
+    it 'responds to predicate-style methods with false' do
+      expect(null.black?).to eq(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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+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(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 +1,13 @@
-$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+GEM_ROOT = File.expand_path("../../", __FILE__)
+$:.unshift File.join(GEM_ROOT, "lib")
+
+if ENV["TRAVIS"]
+  require 'coveralls'
+  Coveralls.wear!
+else
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'naught'
+Dir[File.join(GEM_ROOT, "spec", "support", "**/*.rb")].each { |f| require f }

data/spec/support/convertable_null.rb

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

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: naught
 version: !ruby/object:Gem::Version
-  version: 0.0.2
-  prerelease: 
+  version: 0.0.3
 platform: ruby
 authors:
 - Avdi Grimm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-29 00:00:00.000000000 Z
+date: 2013-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -30,65 +27,71 @@ dependencies:
 - !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'
+        version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.14'
 - !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
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    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
@@ -99,45 +102,86 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
-- .rspec
+- .travis.yml
+- Changelog.md
 - Gemfile
 - Guardfile
 - LICENSE.txt
-- README.org
+- README.markdown
 - Rakefile
 - lib/naught.rb
 - lib/naught/null_class_builder.rb
+- lib/naught/null_class_builder/command.rb
+- lib/naught/null_class_builder/commands.rb
 - lib/naught/null_class_builder/commands/define_explicit_conversions.rb
+- lib/naught/null_class_builder/commands/define_implicit_conversions.rb
+- lib/naught/null_class_builder/commands/impersonate.rb
+- lib/naught/null_class_builder/commands/mimic.rb
+- lib/naught/null_class_builder/commands/pebble.rb
+- lib/naught/null_class_builder/commands/predicates_return.rb
+- lib/naught/null_class_builder/commands/singleton.rb
+- lib/naught/null_class_builder/commands/traceable.rb
+- lib/naught/null_class_builder/conversions_module.rb
 - lib/naught/version.rb
 - naught.gemspec
+- spec/base_object_spec.rb
+- spec/basic_null_object_spec.rb
+- spec/blackhole_spec.rb
+- spec/conversions_spec.rb
+- spec/functions/actual_spec.rb
+- spec/functions/just_spec.rb
+- spec/functions/maybe_spec.rb
+- spec/functions/null_spec.rb
+- spec/implicit_conversions_spec.rb
+- spec/mimic_spec.rb
+- spec/naught/null_object_builder/command_spec.rb
+- spec/naught/null_object_builder_spec.rb
 - spec/naught_spec.rb
+- spec/pebble_spec.rb
+- spec/predicate_spec.rb
+- spec/singleton_null_object_spec.rb
 - spec/spec_helper.rb
+- spec/support/convertable_null.rb
 homepage: https://github.com/avdi/naught
 licenses:
 - MIT
+metadata: {}
 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
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Naught is a toolkit for building Null Objects
 test_files:
+- spec/base_object_spec.rb
+- spec/basic_null_object_spec.rb
+- spec/blackhole_spec.rb
+- spec/conversions_spec.rb
+- spec/functions/actual_spec.rb
+- spec/functions/just_spec.rb
+- spec/functions/maybe_spec.rb
+- spec/functions/null_spec.rb
+- spec/implicit_conversions_spec.rb
+- spec/mimic_spec.rb
+- spec/naught/null_object_builder/command_spec.rb
+- spec/naught/null_object_builder_spec.rb
 - spec/naught_spec.rb
+- spec/pebble_spec.rb
+- spec/predicate_spec.rb
+- spec/singleton_null_object_spec.rb
 - spec/spec_helper.rb
-has_rdoc: 
+- spec/support/convertable_null.rb

data/.rspec

@@ -1 +0,0 @@
--fs --color --order rand

data/README.org

@@ -1,340 +0,0 @@
-#+TITLE: Naught: A Ruby Null Object Library
-
-* A quick intro to Naught
-
-*What's all this now then?*
-
-Naught is a toolkit for building  [[http://en.wikipedia.org/wiki/Null_Object_pattern][Null Objects]] in Ruby.
-
-*What's that supposed to mean?*
-
-Null Objects can make your code more [[http://confidentruby.com][confident]].
-
-Here's a method that's not very sure of itself.
-
-#+BEGIN_SRC ruby
-  class Geordi
-    def make_it_so(logger=nil)
-      logger && logger.info "Reversing the flux phase capacitance!"
-      logger && logger.info "Bounding a tachyon particle beam off of Data's cat!"
-      logger && logger.warn "Warning, bogon levels are rising!"
-    end
-  end
-#+END_SRC
-
-Now, observe as we give it a dash of confidence with the Null Object
-pattern!
-
-#+BEGIN_SRC ruby
-  class NullLogger
-    def debug(*); end
-    def info(*); end
-    def warn(*); end
-    def error(*); end
-    def fatal(*); end
-  end
-  
-  class Geordi
-    def make_it_so(logger=NullLogger.new)
-      logger.info "Reversing the flux phase capacitance!"
-      logger.info "Bounding a tachyon particle beam off of Data's cat!"
-      logger.warn "Warning, bogon levels are rising!"
-    end
-  end
-#+END_SRC
-
-By providing a =NullLogger= which implements [some of] the =Logger=
-interface as no-op methods, we've gotten rid of those unsightly =&&=
-operators.
-
-*That was simple enough. Why do I need a library for it?*
-
-You don't! The Null Object pattern is a very simple one at its core.
-
-*And yet here we are...*
-
-Yes. While you don't /need/ a Null Object library, this one offers
-some conveniences you probably won't find elsewhere.
-
-But there's an even more important reason I wrote this library. In
-the immortal last words of James T. Kirk: "It was... /fun!/"
-
-*OK, so how do I use this thing?*
-
-Well, what would you like to do?
-
-*I dunno, gimme an object that responds to any message with nil*
-
-Sure thing!
-
-#+BEGIN_SRC ruby
-  require 'naught'
-  
-  NullObject = Naught.build
-  
-  null = NullObject.new
-  null.foo                        # => nil
-  null.bar                        # => nil
-#+END_SRC
-
-*That was... weird. What's with this "build" business?*
-
-Naught is a /toolkit/ for building null object classes. It is not a
-one-size-fits-all solution.
-
-What else can I make for you?
-
-*How about a "black hole" null object that supports infinite chaining
-of methods?*
-
-OK.
-
-#+BEGIN_SRC ruby
-  require 'naught'
-  
-  BlackHole = Naught.build do |b|
-    b.black_hole
-  end
-  
-  null = BlackHole.new
-  null.foo                           # => <null>
-  null.foo.bar.baz                   # => <null>
-  null << "hello" << "world"         # => <null>
-#+END_SRC
-
-*What's that "b" thing?*
-
-That stands for "builder". Naught uses the [[http://en.wikipedia.org/wiki/Builder_pattern][Builder Pattern]] for
-rolling custom null object classes.
-
-*Whatever. What if I want a null object that has conversions to Integer, String, etc. using sensible conversions to "zero values"?*
-
-We can do that.
-
-#+BEGIN_SRC ruby
-  require 'naught'
-  
-  NullObject = Naught.build do |b|
-    b.define_explicit_conversions
-  end
-  
-  null = NullObject.new
-  
-  null.to_s                          # => ""
-  null.to_i                          # => 0
-  null.to_f                          # => 0.0
-  null.to_a                          # => []
-  null.to_h                          # => {}
-  null.to_c                          # => (0+0i)
-  null.to_r                          # => (0/1)
-#+END_SRC
-
-*Ah, but what about implicit conversions such as #to_str? Like what if I want a null object that implicitly splats the same way as an
-empty array?*
-
-Gotcha covered.
-
-#+BEGIN_SRC ruby
-  require 'naught'
-  
-  NullObject = Naught.build do |b|
-    b.define_implicit_conversions
-  end
-  
-  null = NullObject.new
-  
-  null.to_str                     # => ""
-  null.to_ary                     # => []
-  
-  a, b, c = []
-  a                               # => nil
-  b                               # => nil
-  c                               # => nil
-  x, y, z = null
-  x                               # => nil
-  y                               # => nil
-  z                               # => nil
-#+END_SRC
-
-*How about a null object that only stubs out the methods from a specific class?*
-
-That's what =mimic= is for.
-
-#+BEGIN_SRC ruby
-  require 'naught'
-  
-  NullIO = Naught.build do |b|
-    b.mimic IO
-  end
-  
-  null_io = NullIO.new
-  
-  null_io << "foo"                # => nil
-  null_io.readline                # => nil
-  null_io.foobar                  # => 
-  # ~> -:11:in `<main>': undefined method `foobar' for 
-  #  <null:IO>:NullIO (NoMethodError)
-#+END_SRC
-
-There is also =impersonate= which takes =mimic= one step further. The
-generated null class will be derived from the impersonated class.
-This is handy when refitting legacy code that contains type checks.
-
-#+BEGIN_SRC ruby
-  require 'naught'
-  
-  NullIO = Naught.build do |b|
-    b.impersonate IO
-  end
-  
-  null_io = NullIO.new
-  IO === null_io                  # => true
-  
-  case null_io
-  when IO
-    puts "Yep, checks out!"
-    null_io << "some output"
-  else
-    raise "Hey, I expected an IO!"
-  end
-  # >> Yep, checks out!
-#+END_SRC
-
-*Alright smartypants. What if I want to add my own methods?*
-
-Not a problem, just define them in the =.build= block.
-
-#+BEGIN_SRC ruby
-  require 'naught'
-  
-  NullObject = Naught.build do |b|
-    b.define_explicit_conversions
-    def to_s
-      "NOTHING TO SEE HERE MOVE ALONG"
-    end
-  
-    def to_path
-      "/dev/null"
-    end
-  end
-  
-  null = NullObject.new
-  null.to_s                       # => "NOTHING TO SEE HERE MOVE ALONG"
-  null.to_path                    # => "/dev/null"
-#+END_SRC
-
-*Got anything else up your sleeve?*
-
-Well, we can make the null class a singleton, since null objects
-generally have no state.
-
-#+BEGIN_SRC ruby
-  require 'naught'
-  
-  NullObject = Naught.build do |b|
-    b.singleton
-  end
-  
-  null = NullObject.instance
-  
-  null.__id__                     # => 17844080
-  NullObject.instance.__id__      # => 17844080
-  NullObject.new                  # => 
-  # ~> -:11:in `<main>': private method `new' called for 
-  #  NullObject:Class (NoMethodError)
-#+END_SRC
-
-Speaking of null objects with state, we can also enable tracing. This
-is handy for playing "where'd that null come from?!" Try doing /that/
-with =nil=!
-
-#+BEGIN_SRC ruby
-  require 'naught'
-  
-  NullObject = Naught.build do |b|
-    b.traceable
-  end
-  
-  null = NullObject.new           # line 7
-  
-  null.__file__                   # => "example.rb"
-  null.__line__                   # => 7
-#+END_SRC
-
-We can even conditionally enable either singleton mode (for
-production) or tracing (for development). Here's an example of using
-the =$DEBUG= global variable (set with the =-d= option to ruby) to
-choose which one.
-
-#+BEGIN_SRC ruby
-  require 'naught'
-  
-  NullObject = Naught.build do |b|
-    if $DEBUG
-      b.traceable
-    else
-      b.singleton
-    end
-  end  
-#+END_SRC
-
-The only caveat is that when swapping between singleton and
-non-singleton implementations, you should be careful to always
-instantiate your null objects with =NullObject.get=, not =.new= or
-=.instance=. =.get= will work whether the class is implemented as a
-singleton or not.
-
-#+BEGIN_SRC ruby
-  NullObject.get                  # => <null>
-#+END_SRC
-
-*Are you done yet?*
-
-Just one more thing. For maximum convenience, Naught-generated null
-classes also come with a full suite of conversion functions which can
-be included into your classes.
-
-#+BEGIN_SRC ruby
-  require 'naught'
-  
-  NullObject = Naught.build
-  
-  include NullObject::Conversions
-  
-  # Convert nil to null objects. Everything else passes through.
-  Maybe(42)                       # => 42
-  Maybe(nil)                      # => <null>
-  Maybe(NullObject.get)           # => <null>
-  Maybe{ 42 }                     # => 42
-  
-  # Insist on a non-null (or nil) value
-  Just(42)                        # => 42
-  Just(nil) rescue $!             # => #<ArgumentError: Null value: nil>
-  Just(NullObject.get) rescue $!  # => #<ArgumentError: Null value: <null>>
-  
-  # nils and nulls become nulls. Everything else is rejected.
-  Null()                          # => <null>
-  Null(42) rescue $!              # => #<ArgumentError: 42 is not null!>
-  Null(nil)                       # => <null>
-  Null(NullObject.get)            # => <null>
-  
-  # Convert nulls back to nils. Everything else passes throuhgh. Useful
-  # for preventing null objects from "leaking" into public API return
-  # values.
-  Actual(42)                      # => 42
-  Actual(nil)                     # => nil
-  Actual(NullObject.get)          # => nil
-  Actual { 42 }                   # => 42
-#+END_SRC
-
-* Requirements
-
-  - Ruby 1.9
-
-* Contributing
-  
-  - Fork, branch, submit PR, blah blah blah. Don't forget tests.
-
-* Who's responsible
-
-  Naught is by [[http://devblog.avdi.org/][Avdi Grimm]].