just_maybe 0.1.0

data/.gitignore

@@ -0,0 +1,18 @@
+.rvmrc
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in just_maybe.gemspec
+gemspec
+
+group :test do 
+  gem 'rspec'
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Michael Greenly
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# 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.
+
+```ruby
+  Maybe(nil).foo.bar.or_else { 'default result' }
+```
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'just_maybe', :git => "git://github.com/mgreenly/justmaybe.git"
+
+And then execute:
+
+    $ bundle
+
+## Background
+
+I created JustMaybe because I wanted a really simple solution that didn't
+introduce any changes to Object.  
+
+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.
+
+## Examples
+
+```ruby
+# Objects wrapped in maybe accept any message and return the result wrapped in maybe
+Maybe(42) * -1   # => Maybe(-42)
+
+# If the Maybe's underlying value doesn't respond to the message it returns Maybe(nil)
+Maybe(42).foo   # => Maybe(nil)
+
+# This allows you to use arbitrarily long method chains with no risk of raising
+# NoMethodError on a nil object
+Maybe(nil).foo.bar.baz   # => Maybe(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"
+   
+# There are a number of convenience methods that operate like or_else for common null values
+Maybe(nil).foo.bar.or_a   # => []
+Maybe(nil).foo.bar.or_f   # => 0.0
+Maybe(nil).foo.bar.or_h   # => {}
+Maybe(nil).foo.bar.or_nil # => nil 
+Maybe(nil).foo.bar.or_s   # => ''
+
+# Remember if you don't call or_else or one of it's alternatives you will get back 
+# an instance of Maybe.  It is possible to get the underlying value back by calling
+# __value__ but I'd generally consider using this a code smell.
+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)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require 'rspec'
+require 'rspec/core/rake_task'
+require "bundler/gem_tasks"
+
+task :default => :spec
+
+desc "Run unit specs"
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = %W[--format documentation --color]
+end

data/just_maybe.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/just_maybe/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Michael Greenly"]
+  gem.email         = ["mgreenly@gmail.com"]
+  gem.description   = %q{A simple implmenetation of the Maybe special case pattern}
+  gem.summary       = %q{A simple implmenetation of the Maybe special case pattern}
+  gem.homepage      = "https://github.com/mgreenly/just_maybe"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "just_maybe"
+  gem.require_paths = ["lib"]
+  gem.version       = JustMaybe::VERSION
+end

data/lib/just_maybe/maybe.rb

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

data/lib/just_maybe/version.rb

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

data/lib/just_maybe.rb

@@ -0,0 +1 @@
+require 'just_maybe/maybe'

data/spec/maybe_spec.rb

@@ -0,0 +1,26 @@
+require 'just_maybe/maybe'
+
+describe Maybe do
+  let(:object) { double }
+
+  it "value returns wrapped object" do 
+    Maybe(object).__value__.should == object
+  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'
+  end
+
+  it "calling a method that does not exist returns Maybe(nil)" do
+    Maybe(object).method_that_does_not_exist.should == Maybe(nil)
+  end
+
+  it "#or_else returns object when object is not nil" do
+    Maybe(object).or_else{'unexpected result'}.should == object
+  end
+
+  it "#or_else returns default when object is nil" do
+    Maybe(nil).or_else{'expected result'}.should == 'expected result'
+  end
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: just_maybe
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Michael Greenly
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-16 00:00:00.000000000 Z
+dependencies: []
+description: A simple implmenetation of the Maybe special case pattern
+email:
+- mgreenly@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- just_maybe.gemspec
+- lib/just_maybe.rb
+- lib/just_maybe/maybe.rb
+- lib/just_maybe/version.rb
+- spec/maybe_spec.rb
+homepage: https://github.com/mgreenly/just_maybe
+licenses: []
+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.19
+signing_key: 
+specification_version: 3
+summary: A simple implmenetation of the Maybe special case pattern
+test_files:
+- spec/maybe_spec.rb