maybe 1.0.0 → 1.1.0

data/README.md

@@ -8,22 +8,28 @@ Synopsis
 
 The Maybe class wraps any value (nil or non-nil) and lets you treat it as non-nil.
 
-     "hello".upcase                         #=> "HELLO"
-     nil.upcase                             #=> NoMethodError: undefined method `upcase' for nil:NilClass
-     Maybe.new("hello").upcase.__value__    #=> "HELLO"
-     Maybe.new(nil).upcase.__value__        #=> nil
+    require "maybe"
+    "hello".upcase                         #=> "HELLO"
+    nil.upcase                             #=> NoMethodError: undefined method `upcase' for nil:NilClass
+    Maybe.new("hello").upcase.__value__    #=> "HELLO"
+    Maybe.new(nil).upcase.__value__        #=> nil
 
 You can also use the method `Maybe` for convenience. The following are equivalent:
 
-     Maybe.new("hello").__value__          #=> "hello"
-     Maybe("hello").__value__              #=> "hello"
+    Maybe.new("hello").__value__           #=> "hello"
+    Maybe("hello").__value__               #=> "hello"
+     
+You can also optionally patch `Object` to include a `#maybe` method:
+
+    require "maybe/core_ext"
+    "hello".maybe.upcase                   #=> "HELLO"
    
 When you call `Maybe.new` with a value, that value is wrapped in a Maybe object. Whenever you call methods on that object, it does a simple check: if the wrapped value is nil, then it returns another Maybe object that wraps nil. If the wrapped object is not nil, it calls the method on that object, then wraps it back up in a Maybe object. 
 
 This is especially handy for long chains of method calls, any of which could return nil.
 
-     # foo, bar, and/or baz could return nil, but this will still work
-     Maybe.new(foo).bar(1).baz(:x)
+    # foo, bar, and/or baz could return nil, but this will still work
+    Maybe.new(foo).bar(1).baz(:x)
 
 Here's a real world example. Instead of writing this:
 
@@ -48,6 +54,8 @@ instead of
 Examples
 --------
 
+    require "maybe"
+
     Maybe.new("10")                    #=> A Maybe object, wrapping "10"
   
     Maybe.new("10").to_i               #=> A Maybe object, wrapping 10

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.1.0

data/lib/maybe.rb

@@ -14,7 +14,7 @@ class Maybe
     @value = value
     __join__
   end
-  
+
   def respond_to?(method_name)
     return true if LEGACY_METHODS.include?(method_name.to_s)
     super || @value.respond_to?(method_name)
@@ -62,7 +62,7 @@ class Maybe
   end
 
   # Only included to provide a complete Monad interface. Not recommended
-  # for general use. 
+  # for general use.
   # (Technically: Given that the value is of type A
   # takes a function from A->M[B] and returns
   # M[B] (a monad with a value of type B))
@@ -71,7 +71,7 @@ class Maybe
   end
 
   # Only included to provide a complete Monad interface. Not recommended
-  # for general use. 
+  # for general use.
   # (Technically: Given that the value is of type A
   # takes a function from A->B and returns
   # M[B] (a monad with a value of type B))
@@ -84,7 +84,7 @@ class Maybe
   end
 
   # Only included to provide a complete Monad interface. Not recommended
-  # for general use. 
+  # for general use.
   # (Technically: M[M[A]] is equivalent to M[A], that is, monads should be flat
   # rather than nested)
   def __join__

data/lib/maybe/core_ext.rb

@@ -0,0 +1,8 @@
+require 'maybe'
+
+class Object
+  def maybe
+    Maybe.new(self)
+  end
+end
+

data/test/core_ext_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path("test_helper", File.dirname(__FILE__))
+
+class CoreExtTest < Test::Unit::TestCase
+
+  context "Object#maybe" do
+
+    should "not include patching by default" do
+      assert_raises NoMethodError do
+        "foo".maybe
+      end
+    end
+
+    should "allow calling foo#maybe rather than Maybe.new(foo)" do
+      require 'maybe/core_ext'
+      assert_kind_of Maybe, "foo".maybe
+    end
+
+    teardown do
+      Object.send(:undef_method, :maybe) if Object.new.respond_to?(:maybe)
+    end
+
+  end
+
+end

data/test/maybe_test.rb

@@ -1,6 +1,7 @@
+# -*- coding: utf-8 -*-
 require File.expand_path("test_helper", File.dirname(__FILE__))
 require 'cgi'
-require 'shoulda'
+require 'maybe'
 
 class MaybeTest < Test::Unit::TestCase
 
@@ -14,14 +15,14 @@ class MaybeTest < Test::Unit::TestCase
       Maybe.any_instance.expects(:__pass__).never
       Maybe.new(Maybe.new(1)).__value__
     end
-    
+
   end
 
   context "when calling methods" do
 
     should "return correct value for match operator" do
       assert_equal nil, (Maybe.new(nil)=~/b/).__value__
-      assert_equal 1, (Maybe.new('abc')=~/b/).__value__    
+      assert_equal 1, (Maybe.new('abc')=~/b/).__value__
     end
 
     should "return correct value for to_s" do
@@ -33,7 +34,7 @@ class MaybeTest < Test::Unit::TestCase
       assert_equal nil, Maybe.new(nil).to_int.__value__
       assert_equal 2, Maybe.new(2.3).to_int.__value__
     end
-    
+
     should "work if method call takes a block" do
       assert_equal nil, Maybe.new(nil).map{|x|x*2}.__value__
       assert_equal [2,4,6], Maybe.new([1,2,3]).map{|x|x*2}.__value__
@@ -41,7 +42,7 @@ class MaybeTest < Test::Unit::TestCase
 
     should "work if methods takes args and a block" do
       assert_equal nil, Maybe.new(nil).gsub(/x/) {|m| m.upcase}.__value__
-      str = Maybe.new('x').gsub(/x/) do |m| 
+      str = Maybe.new('x').gsub(/x/) do |m|
         m.upcase
       end
       assert_equal 'X', str.__value__
@@ -56,7 +57,7 @@ class MaybeTest < Test::Unit::TestCase
   end
 
   context "when calling object_id" do
-    
+
     should "have different object id than wrapped object" do
       wrapped = "hello"
       maybe = Maybe.new(wrapped)
@@ -68,7 +69,7 @@ class MaybeTest < Test::Unit::TestCase
   end
 
   context "#join" do
-    
+
     should "not call #pass" do
       Maybe.any_instance.expects(:__pass__).never
       m = Maybe.new(nil)
@@ -86,7 +87,7 @@ class MaybeTest < Test::Unit::TestCase
   end
 
   context "respond_to?" do
-    
+
     should "respond correctly" do
       klass = Class.new do
         def fmap
@@ -95,7 +96,7 @@ class MaybeTest < Test::Unit::TestCase
         def foo
         end
       end
-      
+
       wrapped = klass.new
       maybe = Maybe.new(wrapped)
 
@@ -121,7 +122,7 @@ class MaybeTest < Test::Unit::TestCase
       assert_equal true, maybe.respond_to?(:__value__)
       assert_equal true, maybe.respond_to?(:__pass__)
     end
-    
+
   end
 
   context "#methods" do
@@ -134,10 +135,10 @@ class MaybeTest < Test::Unit::TestCase
         def foo
         end
       end
-      
+
       wrapped = klass.new
       maybe = Maybe.new(wrapped)
-      
+
       methods = maybe.methods.map{|x| x.to_sym}
 
       assert_equal false, methods.include?(:far)
@@ -167,7 +168,7 @@ class MaybeTest < Test::Unit::TestCase
     end
 
     should "work with CGI.unescape" do
-      # using CGI::unescape because that's the first function I had problems with 
+      # using CGI::unescape because that's the first function I had problems with
       # when implementing Maybe
       assert_equal nil, Maybe.new(nil).pass {|v|CGI.unescapeHTML(v)}.value
       assert_equal '&', Maybe.new('&amp;').pass {|v|CGI.unescapeHTML(v)}.value
@@ -175,11 +176,11 @@ class MaybeTest < Test::Unit::TestCase
       assert_equal nil, Maybe.new(nil).__pass__ {|v|CGI.unescapeHTML(v)}.__value__
       assert_equal '&', Maybe.new('&amp;').__pass__ {|v|CGI.unescapeHTML(v)}.__value__
     end
-    
+
   end
 
   context "#nil?" do
-    
+
     should "be true for nil value" do
       assert_equal true, Maybe.new(nil).nil?
     end
@@ -209,7 +210,7 @@ class MaybeTest < Test::Unit::TestCase
     should "call wrapped object's #value if defined (with params and block)" do
       wrapped = Object.new
       def wrapped.value(value)
-        value * yield 
+        value * yield
       end
       assert_equal 4, Maybe.new(wrapped).value(2) { 2 }
       assert_equal 4, Maybe.new(Maybe.new(wrapped)).value(2) { 2 }
@@ -270,7 +271,7 @@ class MaybeTest < Test::Unit::TestCase
 
     # monad rules taken from http://moonbase.rydia.net/mental/writings/programming/monads-in-ruby/01identity
     # and http://james-iry.blogspot.com/2007_10_01_archive.html
-  
+
     #1. Calling pass on a newly-wrapped value should have the same effect as giving that value directly to the block.
     # (this is actually the second law at http://james-iry.blogspot.com/2007/10/monads-are-elephants-part-3.html)
     # scala version: unit(x) flatMap f ≡ f(x)
@@ -280,7 +281,7 @@ class MaybeTest < Test::Unit::TestCase
       assert_equal f[x], Maybe.new(x).pass {|y| f[y]}.value
       assert_equal f[x], Maybe.new(x).__pass__ {|y| f[y]}.__value__
     end
-  
+
     #2. pass with a block that simply calls wrap on its value should produce the exact same values, wrapped up again.
     # (this is actually the first law at http://james-iry.blogspot.com/2007/10/monads-are-elephants-part-3.html)
     # scala version: m flatMap unit ≡ m

data/test/test_helper.rb

@@ -1,10 +1,10 @@
 require 'rubygems'
 require 'test/unit'
 require 'mocha'
+require 'shoulda'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'maybe'
 
 class Test::Unit::TestCase
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
+  - 1
   - 0
-  - 0
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Ben Brinckerhoff
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-12 00:00:00 -07:00
+date: 2012-07-01 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,25 +40,24 @@ extensions: []
 extra_rdoc_files: 
 - LICENSE
 - README.md
-- README.rdoc
 files: 
 - .document
-- .gitignore
 - LICENSE
 - README.md
 - Rakefile
 - VERSION
 - lib/maybe.rb
+- lib/maybe/core_ext.rb
+- test/core_ext_test.rb
 - test/maybe_test.rb
 - test/test_helper.rb
-- README.rdoc
 has_rdoc: true
 homepage: http://github.com/bhb/maybe
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -82,6 +81,5 @@ rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: A library for treating nil and non-nil objects in a similar manner.
-test_files: 
-- test/maybe_test.rb
-- test/test_helper.rb
+test_files: []
+

data/README.rdoc

@@ -1,83 +0,0 @@
-maybe
-=====
-
-A library for treating nil and non-nil objects in a similar manner. Technically speaking, Maybe is an implemenation of the maybe monad.
-
-Synopsis
---------
-
-The Maybe class wraps any value (nil or non-nil) and lets you treat it as non-nil.
-
-   "hello".upcase                         #=> "HELLO"
-   nil.upcase                             #=> NoMethodError: undefined method `upcase' for nil:NilClass
-   Maybe.new("hello").upcase.__value__    #=> "HELLO"
-   Maybe.new(nil).upcase.__value__        #=> nil
-
-You can also use the method Maybe for convenience. The following are equivalent:
-
-   Maybe.new("hello").__value__          #=> "hello"
-   Maybe("hello").__value__              #=> "hello"
-   
-When you call Maybe.new with a value, that value is wrapped in a Maybe object. Whenever you call methods on that object, it does a simple check: if the wrapped value is nil, then it returns another Maybe object that wraps nil. If the wrapped object is not nil, it calls the method on that object, then wraps it back up in a Maybe object. 
-
-This is especially handy for long chains of method calls, any of which could return nil.
-
-   # foo, bar, and/or baz could return nil, but this will still work
-   Maybe.new(foo).bar(1).baz(:x)
-
-Here's a real world example. Instead of writing this:
-
-  if(customer && customer.order && customer.order.id==newest_customer_id)
-    # ... do something with customer
-  end
-
-just write this:
-
-  if(Maybe.new(customer).order.id.__value__==newest_customer_id)
-    # ... do something with customer
-  end
-
-If your wrapped object does not have a `#value` method, you can call
-
-  Maybe.new(obj).value
-
-instead of
-
-  Maybe.new(obj).__value__
-
-Examples
---------
-
-  Maybe.new("10")                    #=> A Maybe object, wrapping "10"
-
-  Maybe.new("10").to_i               #=> A Maybe object, wrapping 10
-
-  Maybe.new("10").to_i.__value__     #=> 10
-
-  Maybe.new(nil)                     #=> A Maybe object, wrapping nil 
-
-  Maybe.new(nil).to_i                #=> A Maybe object, still wrapping nil
-
-  Maybe.new(nil).to_i.__value__      #=> nil
-
-== Related Reading
-
-* {MenTaLguY has a great tutorial on Monads in Ruby over at Moonbase}[http://moonbase.rydia.net/mental/writings/programming/monads-in-ruby/00introduction.html]
-* {Oliver Steele explores the problem in depth and looks at a number of different solutions}[http://osteele.com/archives/2007/12/cheap-monads]
-* {Reg Braithwaite explores this same problem and comes up with a different, but very cool solution in Ruby}[http://weblog.raganwald.com/2008/01/objectandand-objectme-in-ruby.html]
-* {Weave Jester has another solution, inspired by the Maybe monad}[http://weavejester.com/node/10]
-
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but
-  bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-== Copyright
-
-Copyright (c) 2010 Ben Brinckerhoff. See LICENSE for details.