just_maybe 0.1.0 → 0.1.1

data/README.md

@@ -1,17 +1,22 @@
 # JustMaybe
 
-A simple implementation of the "Maybe" special case pattern.  It allows
-you to safely chain any number of method calls on an object before fetching
-the underlying result or a default value.
+A simple implementation of the "Maybe" - "Special Case" pattern.  
+
+Maybe provides a generic null object that allows you to defer
+the interpretation of what it means to be null until you need
+to use the object.
+
+Specifically they allow you to safely chain any number of method
+calls on an object before returning it or a default value.
 
 ```ruby
-  Maybe(nil).foo.bar.or_else { 'default result' }
+Maybe(nil).foo.bar.or_else { 'default' }
 ```
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'just_maybe', :git => "git://github.com/mgreenly/justmaybe.git"
+    gem "just_maybe", "~> 0.1.0"
 
 And then execute:
 
@@ -20,30 +25,48 @@ And then execute:
 ## Background
 
 I created JustMaybe because I wanted a really simple solution that didn't
-introduce any changes to Object.  
+introduce any changes on Object and I found this paticular syntax very 
+readable.
+
+My paticular use case was for presenter objects that needed to aggregate
+lots of information by walking method chains of a supplied objects.  In 
+this sitation the Presenter is aware of the appropriate default value to
+use if the reference fails.  
 
-My paticular use case was in Presenter objects that needed to collect 
-information from the heirarchy of thier children for display.  In this
-use case the Presenter always knows what it wants, where it's at, and
-what it should use as an alternative if it's not available.
+Using Maybe allows me to get the benefit of null objects without having 
+to modify the underlying code.
 
 ## Examples
 
 ```ruby
-# Objects wrapped in maybe accept any message and return the result wrapped in maybe
-Maybe(42) * -1   # => Maybe(-42)
+require 'just_maybe'
+# => true 
 
-# If the Maybe's underlying value doesn't respond to the message it returns Maybe(nil)
-Maybe(42).foo   # => Maybe(nil)
+# Calling Maybe(object) returns that object wrapped in a instance of Maybe
+Maybe(42)
+# => #<Maybe:0x000000010e7c88> @value=42
 
-# This allows you to use arbitrarily long method chains with no risk of raising
+# An instance of maybe will pass all valid messages to the underlying value
+# and wrap the result in a new instance Maybe
+Maybe(42).next
+# => <Maybe:0x0000000110b0e8> @value=43 
+
+# If the Maybe's underlying value doesn't respond to the message it returns
+# nil wrapped in a new instance of Maybe
+Maybe(42).foo
+# => #<Maybe:0x00000001113540> @value=nil
+
+# This allows you to make arbitrarily long method chains with no risk of raising
 # NoMethodError on a nil object
 Maybe(nil).foo.bar.baz   # => Maybe(nil)
+# => #<Maybe:0x00000001120830> @value=nil 
 
 # Finally Maybe responds to #or_else { ... }.  This causes the Maybe to return the 
 # underlying value if it exists or the result of the block if it does not.
-Maybe([]).append('foo').append('bar').join(' ').or_else { 'baz' }  #  => "foo bar"
-Maybe(nil).append('foo').append('bar').join(' ').or_else { 'baz' } #  => "baz"
+Maybe('FOO').downcase.or_else { 'unknown' }
+# => "foo"
+Maybe(nil).downcase.or_else { 'unknown' }
+# => "unknown"
    
 # There are a number of convenience methods that operate like or_else for common null values
 Maybe(nil).foo.bar.or_a   # => []
@@ -58,11 +81,11 @@ Maybe(nil).foo.bar.or_s   # => ''
 Maybe(42).__value__              # => 42
 Maybe(42).foo.bar.baz.__value__  # => nil
 ```
-
 ## Related
    * [Virtuous Code](http://devblog.avdi.org/2011/05/30/null-objects-and-falsiness/)
    * [mondadic](https://github.com/pzol/monadic)
    * [rumonade](https://github.com/ms-ati/rumonade)
+   * [thoughtbot](http://robots.thoughtbot.com/post/8181879506/if-you-gaze-into-nil-nil-gazes-also-into-you)
 
 ## Contributing
 

data/lib/just_maybe/maybe.rb

@@ -1,72 +1,68 @@
-def Maybe(object)
-  Maybe.new(object)
-end
-
-class Maybe
+class Maybe < BasicObject
   def initialize(object)
-    if object.kind_of?(Maybe)
-      @value = object.__value__
+    if object.kind_of?(::Maybe)
+      @object = object.__value__
     else
-      @value = object
+      @object = object
     end
   end
 
+  def instance_of?(klass)
+    ::Maybe == klass
+  end
+
   def __value__
-      @value
+    @object
   end
-  
+
   def inspect
-    '#<%s:0x%0.14x> @value=%s' % [self.class, object_id * 2, @value.inspect]
+    ::Kernel.sprintf('#<Maybe:0x%0.14x> @object=%s', __id__ * 2, @object.inspect)
   end
 
-  def method_missing(method, *args)
-    if @value.respond_to?(method)
-      Maybe(@value.__send__(method, *args))
-    else
-      Maybe(nil)
+  def method_missing(method, *args, &block)
+    begin
+      ::Maybe.new(@object.__send__(method, *args, &block))
+    rescue ::NoMethodError
+      ::Maybe.new(nil)
     end
   end
 
   def or_a
-    return @value unless @value.nil?
+    return @object unless @object.nil?
     []
   end
 
   def or_else(&block)
-    return @value unless @value.nil?
+    return @object unless @object.nil?
     yield
   end
 
   def or_f
-    return @value unless @value.nil?
+    return @object unless @object.nil?
     0.0
   end
 
   def or_h
-    return @value unless @value.nil?
+    return @object unless @object.nil?
     {}
   end
 
   def or_i
-    return @value unless @value.nil?
+    return @object unless @object.nil?
     0
   end
 
   def or_nil
-    return @value unless @value.nil?
+    return @object unless @object.nil?
     nil
   end
 
   def or_s
-    return @value unless @value.nil?
+    return @object unless @object.nil?
     ''
   end
+end
 
-  def ==(other)
-    if other.kind_of?(Maybe)
-      @value == other.__value__
-    else
-      @value == other
-    end
-  end
+def Maybe(object)
+  Maybe.new(object)
 end

data/lib/just_maybe/version.rb

@@ -1,3 +1,3 @@
 module JustMaybe
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/maybe_spec.rb

@@ -3,24 +3,76 @@ require 'just_maybe/maybe'
 describe Maybe do
   let(:object) { double }
 
-  it "value returns wrapped object" do 
-    Maybe(object).__value__.should == object
+  it "delegates messages to wrapped object" do
+    object.should_receive(:foo).with('bar')
+    Maybe(object).foo('bar')
   end
 
-  it "return values for methods handled by underlying value are wrapped in new Maybe" do
-    object.stub(:some_method).and_return('this object')
-    Maybe(object).some_method.__value__.should == 'this object'
+  it "calling methods that don't exist return Maybe(nil)" do
+    Maybe(nil).foo.__value__.should be_nil 
   end
 
-  it "calling a method that does not exist returns Maybe(nil)" do
-    Maybe(object).method_that_does_not_exist.should == Maybe(nil)
+  it "it doesn't nest" do
+    Maybe(Maybe(nil)).__value__.should_not be_instance_of(Maybe)
   end
 
-  it "#or_else returns object when object is not nil" do
+  it "__value__ unwraps the underlying object" do
+    Maybe(object).__value__.should be(object)
+  end
+
+  it "#or_else returns then underlying object when it's not nil" do
     Maybe(object).or_else{'unexpected result'}.should == object
   end
 
-  it "#or_else returns default when object is nil" do
+  it "#or_else yields to supplied block when the underlying object is nil" do
     Maybe(nil).or_else{'expected result'}.should == 'expected result'
   end
+
+  it "#or_a returns then underlying object when it's not nil" do
+    Maybe(object).or_a.should be(object)
+  end
+
+  it "#or_a defaults to []" do
+    Maybe(nil).or_a.should == []
+  end
+
+  it "#or_f returns then underlying object when it's not nil" do
+    Maybe(object).or_f.should be(object)
+  end
+
+  it "#or_f defaults to 0.0" do
+    Maybe(nil).or_f.should == 0.0
+  end
+
+  it "#or_h returns then underlying object when it's not nil" do
+    Maybe(object).or_h.should be(object)
+  end
+
+  it "#or_h defaults to {}" do
+    Maybe(nil).or_h.should == {} 
+  end
+
+  it "#or_i returns then underlying object when it's not nil" do
+    Maybe(object).or_i.should be(object)
+  end
+
+  it "#or_i defaults to 0" do
+    Maybe(nil).or_i.should == 0 
+  end
+
+  it "#or_nil returns then underlying object when it's not nil" do
+    Maybe(object).or_nil.should be(object)
+  end
+
+  it "#or_nil defaults to nil" do
+    Maybe(nil).or_nil.should == nil 
+  end
+
+  it "#or_s returns then underlying object when it's not nil" do
+    Maybe(object).or_s.should be(object)
+  end
+
+  it "#or_s defaults to ''" do
+    Maybe(nil).or_s.should == '' 
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: just_maybe
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors: