schrodingers-cat 1.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+-
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/CHANGELOG.rdoc

@@ -0,0 +1,7 @@
+== 0.1.4
+
+* Additionally switches to justools instead of core utilities
+
+== 0.1.2
+
+* Support for Rails > 3.1.1

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.11.0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", "~> 1.8.4"
+  # gem "rcov", ">= 0"
+  gem 'i18n'
+  gem 'activesupport', '>= 3.1.0'
+  gem 'justools', '~> 1.1.8', :github => 'caleon/justools'
+end

data/Gemfile.lock

@@ -0,0 +1,44 @@
+GIT
+  remote: git://github.com/caleon/justools.git
+  revision: 0f5215f4c6777fc96795924d62f4e2200602f5e3
+  specs:
+    justools (1.1.10)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.1.1)
+      multi_json (~> 1.0)
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    i18n (0.6.1)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.5)
+    multi_json (1.0.3)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (>= 3.1.0)
+  bundler (>= 1.0.0)
+  i18n
+  jeweler (~> 1.8.4)
+  justools (~> 1.1.8)!
+  rdoc (~> 3.12)
+  rspec (~> 2.11.0)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 caleon
+
+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.rdoc

@@ -0,0 +1,99 @@
+= Schrodinger's Cat
+
+== Usage:
+
+    gem 'schrodingers-cat'
+    # or with GitHub for latest:
+    gem 'schrodinger', :git => "git://github.com/caleon/schrodinger.git"
+
+== Use case:
+
+Able to avoid common patterns like:
+
+  user_or_id.is_a?(User) ? user_or_id.id : user_or_id
+
+in favor of
+
+  user_or_id.if_a?(User).id # or
+  user_or_id.if_a?(User, :else => user_or_id).id
+  user_or_id.only_if_a?(User) || user_or_id
+
+== Note:
+
+These can't be overriden as they are not methods but low-level operators... ):
+
+  define_method(:"&&") {|obj| false }; define_method(:"||") {|obj| obj }
+
+which means we can't reliably do something like
+
+  record.assuming_a(User).authentications.first || raise "You didn't supply a user with authentications!"
+
+because if sc.is_a?(SchrodingersCat), we ideally want:
+
+  sc || false     # => false
+  true && sc      # => false
+
+but instead, as || and && are low-level operators for short-circuiting, we get:
+
+  sc || false     # => sc
+  true && sc      # => sc
+
+However, though normally nil is the only object which should respond to #nil? with a true, so does SchrodingersCat whose MODEL_OBJECT is nil.
+
+== Examples:
+
+=== Example 1:
+
+if user_or_id.is_a?(User) then do #id, else just return user_or_id
+
+      user_or_id = User.first
+      user_or_id.if_a?(User).id
+  =>  1
+      user_or_id = User.first.id
+      user_or_id.if_a?(User).id
+  =>  1
+
+
+=== Example 2:
+
+Only if user_or_id.is_a?(User) run chained method normally. Otherwise, return nil on chained method call.
+
+      possible_match = "hello".match(/ello/)
+      possible_match.only_if_a?(MatchData)[0]
+  =>  "ello"
+      possible_match = "hello".match(/superman/)
+      possible_match.only_if_a?(MatchData)[0]
+  =>  nil
+
+
+=== Example 3:
+
+If user_or_id.is_a?(User) continue with chain, else continue returning Schrodinger's Cat.
+
+      user_or_id = User.first
+    	res = user_or_id.assuming_a(User).authentications.first.provider # assuming an authentications record exists.
+  =>  "facebook"
+    	res.class
+  =>  String
+      user_or_id = User.find_by_email('nobody@juscribe.com') # if there is no user with that email,
+    	res = user_or_id.assuming_a(User).authentications.first.provider
+  =>  nil
+    	res.class
+  =>  SchrodingersCat
+
+
+== Additional information
+
+=== Contributors
+
+We have a short list of valued contributors. Check them all at:
+
+http://github.com/caleon/schrodinger/contributors
+
+=== Maintainers
+
+* caleon (http://github.com/caleon)
+
+== License
+
+MIT License. Copyright 2011-2012 caleon.

data/Rakefile

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "schrodingers-cat"
+  gem.homepage = "http://github.com/caleon/schrodinger"
+  gem.license = "MIT"
+  gem.summary = %Q{A convenience utility for dealing with the unknown state of an object's existence in order to avoid common code inelegance.}
+  gem.description = <<-DESC
+    The Schrodinger's Cat gem is a library that boasts neither novelty or
+    ingenuity, just the potential for writing more efficient code when it comes
+    to (and we've all been there) dealing with the ubiquitous cases wherein the
+    existence (or nil'ness) of the object referenced is ever in flux. To this
+    end, Schrodinger's Cat defines Object-level methods designed for theses
+    common cases.
+  DESC
+  gem.email = "caleon@gmail.com"
+  gem.authors = ["caleon"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Schrodinger's Cat #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/init.rb

@@ -0,0 +1,2 @@
+# require File.expand_path('../lib/schrodingers_cat', __FILE__)
+require 'schrodinger'

data/lib/schrodingers/cat.rb

@@ -0,0 +1,2 @@
+# File exists only to resolve default library path lookup when name has dash.
+require File.expand_path('../../schrodingers-cat', __FILE__)

data/lib/schrodingers-cat.rb

@@ -0,0 +1,6 @@
+require 'active_support/core_ext/module'
+require 'active_support/core_ext/array/wrap'
+
+require 'justools'
+require 'schrodingers_cat/schrodingers_cat'
+require 'schrodingers_cat/core_ext'

data/lib/schrodingers_cat/core_ext.rb

@@ -0,0 +1,88 @@
+class Object
+  # if user_or_id.is_a?(User) then do #id, else just return user_or_id
+  # Ex: user_or_id = User.first
+  #     user_or_id.if_a?(User).id
+  # =>  1
+  #     user_or_id = User.first.id
+  #     user_or_id.if_a?(User).id
+  # =>  1
+  def if_a?(*others, &block)
+    others.flatten_splat! # decide whether im using these or not. already using merge_options and shit.
+    opts = others.extract_options!
+    check_conditions = opts.key?(:conditions) ? opts.delete(:conditions) : send((opts.delete(:check) || :is_one_kind_of?), *others)
+    if opts.delete(:opposite) ? !check_conditions : check_conditions
+      block_given? ? yield(self) : self
+    else # :else => self is the default, for when i dont do any operations on original object.
+      opts.merge!(:else => self)  unless opts.key?(:else) || opts[:chain] # if opts[:chain] is passed, then there is never an :else.
+      return opts[:else]          if block_given? && opts.key?(:else)
+      SchrodingersCat.new(self, opts)
+    end
+  end
+
+  def unless_a?(*others, &block)
+    if_a?(*others.merge_options!(:opposite => true), &block)
+  end
+
+  # Only if user_or_id.is_a?(User) run chained method normally. Otherwise, return nil on chained method call.
+  # Ex: possible_match = "hello".match(/ello/)
+  #     possible_match.only_if_a?(MatchData)[0]
+  # =>  "ello"
+  #     possible_match = "hello".match(/superman/)
+  #     possible_match.only_if_a?(MatchData)[0]
+  # =>  nil
+  def only_if_a?(*others, &block)
+    if_a?(*others.merge_options(:else => nil), &block)
+  end
+
+  def only_unless_a?(*others, &block)
+    only_if_a?(*others.merge_options(:opposite => true), &block)
+  end
+
+  # if user_or_id.is_a?(User) continue with chain, else continue returning Schrodinger's Cat.
+  # Ex: user_or_id = User.first
+  #     res = user_or_id.assuming_a(User).authentications.first.provider # assuming an authentications record exists.
+  # =>  "facebook"
+  #     res.class
+  # =>  String
+  #     user_or_id = User.find_by_email('noone@kibblr.com') # if there is no user with ID=999,
+  #     res = user_or_id.assuming_a(User).authentications.first.provider
+  # =>  nil
+  #     res.class
+  # =>  SchrodingersCat
+  def assuming_a(*others, &block)
+    if_a?(*others.merge_options(:chain => true), &block)
+  end
+
+  ##################################
+  # Exact comparison of #== in is_one_of? rather than utilizing #=== in #is_one_kind_of
+  ###############################
+  def if_equals_a?(*others, &block);                     if_a?(*others.merge_options(:conditions  => in?(others)), &block); end
+  def unless_equals_a?(*others, &block);          if_equals_a?(*others.merge_options(:opposite    => true),             &block); end
+  def only_if_equals_a?(*others, &block);         if_equals_a?(*others.merge_options(:else        => nil),              &block); end
+  def only_unless_equals_a?(*others, &block); unless_equals_a?(*others.merge_options(:else        => nil),              &block); end
+  def assuming_equals_a(*others, &block);         if_equals_a?(*others.merge_options(:chain       => true),             &block); end
+
+  #########################
+  # Custom conditionals. ##
+  #########################
+  def if?(varied, *args, &block)      if_a?(*args.merge_options(:conditions => resolve_conditions(varied)), &block); end
+  def unless?(*args, &block);           if?(*args.merge_options(:opposite   => true),                       &block); end
+  def only_if?(*args, &block);          if?(*args.merge_options(:else       => nil),                        &block); end
+  def only_unless?(*args, &block); only_if?(*args.merge_options(:opposite   => true),                       &block); end
+  #def assuming(*args, &block);          if?(*args.merge_options(:chain      => true),                       &block); end
+
+  #########################
+  # Utilities            ##
+  #########################
+  def present_else_nil;     present_else(nil);     end
+  def significant_else_nil; significant_else(nil); end
+
+  protected
+  def present_else(other);     if?(:present?,     :else => other) { self }; end
+  def significant_else(other); if?(:significant?, :else => other) { self }; end
+
+  private
+  def resolve_conditions(varied)
+    varied.is_a?(Symbol) ? __send__(varied) : varied.is_a?(Array) ? __send__(*varied) : varied.is_a?(String) ? varied =~ /^\./ ? __send__(:eval, "self#{varied}") : eval(varied) : !!varied
+  end
+end

data/lib/schrodingers_cat/dependencies.rb

@@ -0,0 +1,7 @@
+# Not used right now.
+class Array
+  def compact_with_schrodinger
+    compact_without_schrodinger.reject(&:nil?)
+  end
+  alias_method_chain :compact, :schrodinger
+end

data/lib/schrodingers_cat/schrodingers_cat.rb

@@ -0,0 +1,56 @@
+class SchrodingersCat
+  #######################
+  ## Schrodinger's Cat ##
+  #######################
+  #
+  # Able to avoid shit like: user_or_id.is_a?(User) ? user_or_id.id : user_or_id
+  # in favor of user_or_id.if_a?(User).id
+  # or          user_or_id.if_a?(User, :else => user_or_id).id
+  # or          user_or_id.only_if_a?(User) || user_or_id
+
+  #####################
+  ## Note:           ##
+  #####################
+  # These can't be overriden as they are not methods but low-level operators... ):
+  #   define_method(:"&&") {|obj| false }; define_method(:"||") {|obj| obj }
+  # which means I can't reliably do something like record.assuming_a(User).authentications.first || raise "You didn't supply a user with authentications!"
+  # because if sc.is_a?(SchrodingersCat), we ideally want:
+  # sc || false     # => false
+  # true && sc      # => false
+  # but instead, as || and && are low-level operators for short-circuiting, we get:
+  # sc || false     # => sc
+  # true && sc      # => sc
+  # However, though normally nil is the only object which should respond to #nil? with a true, so does SchrodingersCat whose MODEL_OBJECT is nil.
+  attr_accessor :original, :method_chain, :else
+  unless const_defined?(:MODEL_OBJECT)
+    SchrodingersCat.const_set(:MODEL_OBJECT, nil)
+  end
+
+  def initialize(original, attrs={})
+    self.original, self.method_chain  = original, Array.wrap(attrs[:method_chain])
+    self.else, @_else_set             = attrs[:else], true if attrs.key?(:else)
+  end
+
+  [ 'inspect', 'to_s', 'to_i', 'nil?', 'empty?' ,'blank?' ].each do |meth|
+    class_eval %{ def #{meth}; MODEL_OBJECT.#{meth}; end; }
+  end
+  #delegate *[ 'inspect', 'to_s', 'to_i', 'nil?', 'empty?' ,'blank?' ].map(&:intern), :to => :MODEL_OBJECT
+
+  # if Rails.env.development?
+  #   def inspect; "nil (SchrodingersCat)"; end
+  # end
+
+  [ "==", "eql?", "&", "^", "|" ].each do |meth|
+    class_eval %{ def #{meth}(other); MODEL_OBJECT.#{meth}(other); end; }
+  end
+  #delegate *[ "==", "eql?", "&", "^", "|" ].map(&:intern), :to => :MODEL_OBJECT
+
+  def dup; nil; end
+
+  def method_missing(method_sym, *arguments, &block)
+    return self.else if @_else_set
+    self.method_chain << { method_sym => arguments.push(&block) }
+    self
+  end
+  private :method_missing
+end

data/lib/tasks/schrodinger_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :schrodinger do
+#   # Task goes here
+# end

data/spec/schrodingers-cat_spec.rb

@@ -0,0 +1,346 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Schrodinger's Cat" do
+
+  specify 'SchrodingersCat class should be defined' do
+    defined?(SchrodingersCat).should be_true
+  end
+
+  # describe Array do
+  #   it { should respond_to :compact_with_schrodinger }
+  # end
+
+  describe SchrodingersCat do
+    let(:original) { mock('original') }
+    subject(:cat) { described_class.new(original) }
+
+    it 'is modeled after nil' do
+      described_class::MODEL_OBJECT.should be_nil
+    end
+
+    its(:dup) { should be_nil }
+  end
+
+  describe Object do
+    before(:each) do
+      subject.stub(:do_something => :result)
+    end
+
+    describe 'Basic responses' do
+      %w(if_a? unless_a? only_if_a? only_unless_a? assuming_a if_equals_a?
+         unless_equals_a? only_if_equals_a? only_unless_equals_a?
+         assuming_equals_a if? unless? only_if? only_unless?).each do |meth|
+        it { should respond_to meth.to_sym }
+      end
+    end
+
+    describe '#if_a?' do
+      it 'returns self for false check' do
+        subject.if_a?(Numeric).do_something.should be subject
+      end
+
+      it 'calls chained method for true check' do
+        subject.if_a?(Object).do_something.should == :result
+      end
+
+      it 'returns evaluated block for true check' do
+        subject.if_a?(Object) { |o| o.do_something }.should == :result
+      end
+
+      context 'with custom :conditions' do
+        it 'evaluates uses :conditions for truth check' do
+          subject.if_a?(Numeric, :conditions => true).do_something.should == :result
+          subject.if_a?(Numeric, :conditions => false).do_something.should be subject
+        end
+      end
+
+      context 'with custom :check requested' do
+        it 'calls the :check method instead of :is_one_kind_of?' do
+          subject.should_receive(:some_check).with(Numeric)
+          subject.if_a?(Numeric, :check => :some_check)
+        end
+      end
+
+      context 'with :opposite conditions requested' do
+
+        it 'returns self for true check' do
+          subject.if_a?(Object, :opposite => true).do_something.should be subject
+        end
+
+        it 'calls chained method for false check' do
+          subject.if_a?(Numeric, :opposite => true).do_something.should == :result
+        end
+
+        it 'returns evaluated block for false check' do
+          subject.if_a?(Numeric, :opposite => true) { |o| o.do_something }.should == :result
+        end
+      end
+
+      context 'with custom :else provided' do
+
+        it 'returns self for true check' do
+          subject.if_a?(Object, :else => :something_else).do_something.should == :result
+        end
+
+        it 'returns else for false check' do
+          subject.if_a?(Numeric, :else => :something_else).do_something.should == :something_else
+        end
+      end
+
+      context 'with custom :chain provided' do
+
+        it 'returns a SchrodingersCat' do
+          subject.if_a?(Numeric, :chain => true).do_something.should be_a SchrodingersCat
+        end
+      end
+    end
+
+    describe '#unless_a?' do
+      it 'simply calls #if_a? with :opposite => true' do
+        subject.should_receive(:if_a?).with(Numeric, hash_including(:opposite => true))
+        subject.unless_a?(Numeric)
+      end
+    end
+
+    describe '#only_if_a?' do
+      it 'simply calls #if_a? with :else => nil' do
+        subject.should_receive(:if_a?).with(Numeric, hash_including(:else => nil))
+        subject.only_if_a?(Numeric)
+      end
+    end
+
+    describe '#only_unless_a?' do
+      it 'simply calls #only_if_a? with :opposite => true' do
+        subject.should_receive(:only_if_a?).with(Numeric, hash_including(:opposite => true))
+        subject.only_unless_a?(Numeric)
+      end
+    end
+
+    describe '#assuming_a' do
+      it 'simply calls #if_a? with :chain => true' do
+        subject.should_receive(:if_a?).with(Numeric, hash_including(:chain => true))
+        subject.assuming_a(Numeric)
+      end
+    end
+
+    describe '#if_equals_a?' do
+      it 'simply calls #if_a? with :check => :is_included_in?' do
+        subject.should_receive(:if_a?).with(Numeric, hash_including(:conditions))
+        subject.if_equals_a?(Numeric)
+      end
+    end
+
+    describe '#unless_equals_a?' do
+      it 'simply calls #if_equals_a? with :opposite => true' do
+        subject.should_receive(:if_equals_a?).with(Numeric, hash_including(:opposite => true))
+        subject.unless_equals_a?(Numeric)
+      end
+    end
+
+    describe '#only_if_equals_a?' do
+      it 'simply calls #if_equals_a? with :else => nil' do
+        subject.should_receive(:if_equals_a?).with(Numeric, hash_including(:else => nil))
+        subject.only_if_equals_a?(Numeric)
+      end
+    end
+
+    describe '#only_unless_equals_a?' do
+      it 'simply calls #unless_equals_a? with :else => nil' do
+        subject.should_receive(:unless_equals_a?).with(Numeric, hash_including(:else => nil))
+        subject.only_unless_equals_a?(Numeric)
+      end
+    end
+
+    describe '#assuming_equals_a' do
+      it 'simply calls #if_equals_a? with :chain => true' do
+        subject.should_receive(:if_equals_a?).with(Numeric, hash_including(:chain => true))
+        subject.assuming_equals_a(Numeric)
+      end
+    end
+
+    describe '#if?' do
+      it 'simply calls #if_a? with :conditions => something' do
+        Object.any_instance.stub(:resolve_conditions => :resolved_conditions)
+        subject.should_receive(:if_a?).with(hash_including(:conditions => :resolved_conditions))
+        subject.if?(:varied)
+      end
+    end
+
+    describe '#unless?' do
+      it 'simply calls #if? with :opposite => true' do
+        subject.should_receive(:if?).with(:varied, hash_including(:opposite => true))
+        subject.unless?(:varied)
+      end
+    end
+
+    describe '#only_if?' do
+      it 'simply calls #if? with :else => nil' do
+        subject.should_receive(:if?).with(:varied, hash_including(:else => nil))
+        subject.only_if?(:varied)
+      end
+    end
+
+    describe '#only_unless?' do
+      it 'simply calls #only_if? with :opposite => true' do
+        subject.should_receive(:only_if?).with(:varied, hash_including(:opposite => true))
+        subject.only_unless?(:varied)
+      end
+    end
+  end # / describe Object
+
+  describe 'Real world examples' do
+    let(:hash) { { :a => 3 } }
+
+    describe '#if_a?' do
+
+      it 'checks false and returns self despite method' do
+        hash.if_a?(Numeric).keys.should == hash
+      end
+
+      it 'checks true and calls the chained method' do
+        hash.if_a?(Hash).keys.should == [:a]
+      end
+
+      it 'checks true and returns the result of block' do
+        hash.if_a?(Hash) { |h| h.keys }.should == [:a]
+      end
+    end
+
+    describe '#unless_a?' do
+
+      it 'checks false and returns self despite method' do
+        hash.unless_a?(Hash).keys.should == hash
+      end
+
+      it 'checks true and calls the chained method' do
+        hash.unless_a?(Numeric).keys.should == [:a]
+      end
+
+      it 'checks true and returns the result of block' do
+        hash.unless_a?(Numeric) { |h| h.keys }.should == [:a]
+      end
+    end
+
+    describe '#only_if_a?' do
+
+      it 'checks false and returns nil' do
+        hash.only_if_a?(String).to_sym.should be_nil
+      end
+
+      it 'checks true and calls the method' do
+        hash.only_if_a?(Hash).keys.should == [:a]
+      end
+    end
+
+    describe '#only_unless_a?' do
+
+      it 'checks false and returns nil' do
+        hash.only_unless_a?(Hash).to_sym.should be_nil
+      end
+
+      it 'checks true and calls the method' do
+        hash.only_unless_a?(String).keys.should == [:a]
+      end
+    end
+
+    describe '#assuming_a' do
+
+      it 'allows chaining of methods without error even if check was false' do
+        expect { hash.assuming_a(String).upcase.capitalize.downcase
+          }.not_to raise_error
+      end
+
+      it 'returns a SchrodingersCat if check was false' do
+        result = hash.assuming_a(String).upcase.capitalize.downcase
+        result.should be_a SchrodingersCat
+        result.inspect.should == 'nil'
+      end
+    end
+
+    describe '#if_equals_a?' do
+
+      it 'checks false and returns self' do
+        hash.if_equals_a?({ 'a' => 4 }).keys.should be hash
+        3.if_equals_a?(4).keys.should == 3
+      end
+
+      it 'checks true and calls the method' do
+        # hash.if_equals_a?({ 'a' => 4 }, { :a => 4 }).keys.should == [:a] # FIXME: merging options assumes the latest of arguments is not an arg but an option...
+        3.if_equals_a?(0, 3).succ.should == 4
+      end
+    end
+
+    describe '#unless_equals_a?' do
+
+      it 'checks false and returns self' do
+        3.unless_equals_a?(3).keys.should == 3
+      end
+
+      it 'checks true and calls the method' do
+        3.unless_equals_a?(0, 1).succ.should == 4
+      end
+    end
+
+    describe '#only_if_equals_a?' do
+
+      it 'checks false and returns nil' do
+        3.only_if_equals_a?(4).keys.should be_nil
+      end
+
+      it 'checks true and calls the method' do
+        3.only_if_equals_a?(1, 2, 3).succ.should == 4
+      end
+    end
+
+    describe '#only_unless_equals_a?' do
+
+      it 'checks false and returns nil' do
+        3.only_unless_equals_a?(3, 4).keys.should be_nil
+      end
+
+      it 'checks true and calls the method' do
+        3.only_unless_equals_a?(1, 2).succ.should == 4
+      end
+    end
+
+    describe '#assuming_equals_a' do
+
+      it 'checks false and returns SchrodingersCat' do
+        3.assuming_equals_a(4).succ.succ.succ.should be_a SchrodingersCat
+      end
+
+      it 'checks true and calls the chained methods' do
+        3.assuming_equals_a(3).succ.succ.succ.should == 6
+      end
+    end
+
+    describe '#if?' do
+
+      it 'checks custom predicate symbol' do
+        3.if?(:odd?).succ.should == 4
+        3.if?(:even?).succ.should == 3
+      end
+
+      it 'checks custom predicate symbol with a method' do
+        3.if?([:is_a?, Numeric]).succ.should == 4
+        3.if?([:is_a?, Array]).first.should == 3
+      end
+
+      it 'checks the return of sending receiver an arbitrary method supplied as String beginning with a period' do
+        3.if?('.succ.even?').succ.should == 4
+        3.if?('.succ.odd?').succ.should == 3
+      end
+
+      it 'checks the return of arbitrary method supplied as String' do
+        3.if?('Date.new.is_a?(Date)').succ.should == 4
+        3.if?('Date.new.is_a?(String)').succ.should == 3
+      end
+    end
+
+    # No need to belabor the point. You get it, right?
+    # describe '#unless?'
+    # describe '#only_if?'
+    # describe '#only_unless?'
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'schrodingers-cat'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.alias_it_should_behave_like_to :it_has_behavior, 'has behavior:'
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification 
+name: schrodingers-cat
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- caleon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-10-22 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 2
+        - 11
+        - 0
+        version: 2.11.0
+  prerelease: false
+  type: :development
+  name: rspec
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 3
+        - 12
+        version: "3.12"
+  prerelease: false
+  type: :development
+  name: rdoc
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  prerelease: false
+  type: :development
+  name: bundler
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 1
+        - 8
+        - 4
+        version: 1.8.4
+  prerelease: false
+  type: :development
+  name: jeweler
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  name: i18n
+  requirement: *id005
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 3
+        - 1
+        - 0
+        version: 3.1.0
+  prerelease: false
+  type: :development
+  name: activesupport
+  requirement: *id006
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 1
+        - 8
+        version: 1.1.8
+  prerelease: false
+  type: :development
+  name: justools
+  requirement: *id007
+description: "    The Schrodinger's Cat gem is a library that boasts neither novelty or\n    ingenuity, just the potential for writing more efficient code when it comes\n    to (and we've all been there) dealing with the ubiquitous cases wherein the\n    existence (or nil'ness) of the object referenced is ever in flux. To this\n    end, Schrodinger's Cat defines Object-level methods designed for theses\n    common cases.\n"
+email: caleon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .rspec
+- CHANGELOG.rdoc
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- init.rb
+- lib/schrodingers-cat.rb
+- lib/schrodingers/cat.rb
+- lib/schrodingers_cat/core_ext.rb
+- lib/schrodingers_cat/dependencies.rb
+- lib/schrodingers_cat/schrodingers_cat.rb
+- lib/tasks/schrodinger_tasks.rake
+- spec/schrodingers-cat_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/caleon/schrodinger
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A convenience utility for dealing with the unknown state of an object's existence in order to avoid common code inelegance.
+test_files: []
+