reactive_support 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a142b1256893c0aa5c9a3f28b9eb22a4ea88ee04
+  data.tar.gz: 9a988e249e3c15236caeb44bd61549555532a0f7
+SHA512:
+  metadata.gz: dc50c7a5966a2b58b7a338d9c4b045958cca11a71efe3059812125a67280f612e71359fc10f4d38a7ed7cc408d6ac7a94c6bf07c7bdced0e25b9a68643dc50c8
+  data.tar.gz: 6f0c09ccafbab6e586d3fd54db73587bf5806247507213ef5f53e8c1a150260efe1975354deb53a7786d198b1d40bf2a921d7bbee86edfad64d6b03cf369bc26

data/CONTRIBUTING.md

@@ -0,0 +1,162 @@
+## Contributing to ReactiveSupport
+ReactiveSupport is a small project with only one maintainer (nice to meet you),
+so your contributions are much appreciated. Here are some guidelines to improve 
+the chances your pull request will be accepted.
+
+#### Summary Guidelines
+The more of these guidelines you read, the more likely it is your pull request
+will be accepted. That said, here is the TL;DR version. (Details are available in 
+later sections.)
+
+DO...
+  * Expand existing functionality
+  * Fix bugs
+  * Add or improve tests and documentation
+  * Feel free to add new files as needed(make sure to add them to the
+    gemspec too!)
+  * Keep everything consistent with the ActiveSupport API
+  * Include robust, passing RSpec examples with your PR
+  * Include extensive [RDoc](https://github.com/rdoc/rdoc) comments
+  * Keep your code DRY and concise - be mindful of best practices
+  * Familiarize yourself with the metrics used on this project
+  * Familiarize yourself with the vision and values of this project
+  * Run the full test suite before making your PR
+  * File an issue report or message me if you have any questions
+    (I don't bite!)
+
+DON'T...
+  * Worry that your pull request is too small - all improvements are welcome
+  * Break backward compatibility
+  * Modify existing functionality (unless required to fix a bug)
+  * Add dependencies
+  * Add functionality that is not present in ActiveSupport
+  * Submit a PR with breaking changes or no passing tests
+  * Submit changes that only work with particular tools, gemsets, 
+    environments, or Ruby versions
+
+Thank you for your contributions!
+
+#### Types of Contributions
+I'll consider all contributions, but the following would be 
+particularly helpful.
+
+##### Bug fixes
+If you find a bug affecting ReactiveSupport's interaction with other gems,
+frameworks, tools, platforms, rubies, or environments, your issue report
+or patch is much appreciated. If your fix has to do with Rails, you will
+also need to explain why ReactiveSupport would be included in a Rails project
+since I can't think of a reason.
+
+##### Additional ActiveSupport methods
+Most of the ActiveRecord methods I'm including are those that I find directly
+relevant to [my other project](https://github.com/danascheider/canto). I
+encourage pull requests that add methods that would be useful to you or others.
+
+##### Additional or improved tests or docs
+ReactiveSupport uses RSpec and RDoc for testing and documentation, respectively.
+Improvements in coverage or quality of tests and documentation are very helpful.
+
+#### Project Vision
+Your pull request is more likely to be successful if you keep ReactiveSupport's 
+vision and values in mind. This gem is:
+
+##### Unopinionated, agnostic, and independent
+ReactiveSupport is intended to provide additional, useful functionality to all 
+Ruby developers. Successful pull requests will work regardless of platform,
+environment, tooling, or gemsets, and will do so without adding dependencies.
+
+##### Stable and compatible
+ReactiveSupport exists so users can have access to ActiveSupport's useful methods
+without relying on Rails, whose frequent changes and reorganizations can hurt 
+projects relying on its components. Changes you submit must not adversely affect
+backwards compatibility or break existing functionality. **This is the single most 
+important rule for contributing to ReactiveSupport.** 
+
+##### Functionally identical to ActiveSupport
+A person should be able to learn about a ReactiveSupport method by reading the 
+ActiveSupport documentation on the corresponding method. Note that this rule
+is subordinated to the previous one. Stability and compatibility come first, always.
+
+##### Test-driven and test-first
+ReactiveSupport development is guided by the principles of behavior-driven
+development. Look at existing spec files and notice how many examples are included
+for each method. Test coverage is measured by [Coveralls](http://coveralls.io), 
+and 100% coverage by robust, detailed tests is the standard for this project.
+
+##### Well documented
+[Inch CI](http://inch-ci.org) is being used to evaluate the thoroughness of 
+ReactiveSupport's [RDoc](https://github.com/rdoc/rdoc) documentation.
+Please include detailed documentation with your pull request.
+
+##### Mindful of metrics
+As a perfectionistic and slightly neurotic individual, I have configured the
+following tools for evaluating different aspects of the ReactiveSupport gem.
+Please familiarize yourself with them:
+  * **[Travis CI](https://travis-ci.org)** is used to ensure all tests pass. 
+    Commits that break Travis builds make me a 
+    [sad panda](http://www.urbandictionary.com/define.php?term=sad+panda). 
+  * **[Coveralls](https://coveralls.io)** is used to evaluate extent of 
+    test coverage. The goal is 100% coverage, which is an achievable goal.
+  * **[CodeClimate](http://codeclimate.com)** is used to evaluate code 
+    quality. I consider a CodeClimate score below 3.5 unacceptably low for
+    this project. (You can easily check your fork before submitting.)
+  * **[Inch CI](http://inch-ci.org)** is used to evaluate documentation.
+    Don't worry too much about what Inch says (it's newish and buggy), but 
+    *do* take the time to include quality docs.
+
+#### Style Guide
+Development of ReactiveSupport is guided by best practices. This is a simple
+gem and it should be DRY, concise, and thoroughly documented.
+Here are some of the best practices and stylistic guidelines I like my projects
+to adhere to:
+  * `unless` is preferred to `if not`
+  * Single-line blocks use curly braces
+  * Multi-line blocks use `do`...`end` syntax
+  * Single quotes are preferred to double quotes when there's a choice
+  * Fewer lines good, more lines bad (see below for examples)
+  * More files are better than large files*
+  * RSpec `describe` and `context` blocks are good
+  * RSpec `let` syntax is good
+  * RSpec examples should have a single point of failure
+
+And here are some smells to avoid (may be OK in some cases):
+  * One RSpec example has multiple points of failure
+  * A value is hard-coded
+  * A method is more than 3 lines long or contains nested conditionals or blocks
+
+Note that monkey patching is NOT considered a smell in ReactiveSupport as long
+as it solves a problem not solved within the ReactiveSupport module itself.
+
+\* But don't forget to update the gemspec!
+
+##### Examples: Fewer lines good, more lines bad
+Lots of things can be reduced to a single line, especially blocks and conditionals.
+
+    # This:
+    array.map do |num|
+      puts "#{num} is now #{num + 1}"
+      num += 1
+    end
+
+    # Should be turned into this:
+    array.map {|item| puts "#{item} is now #{item += 1}" }
+
+    # And this: 
+    if foo.defined?
+      puts "It's defined!"
+    else 
+      puts "It's not defined!"
+    end
+
+    # Should look more like this:
+    puts foo.defined? ? "It's defined!" : "It's not defined!"
+
+    # And finally, this: 
+    begin
+      return message = foo.message
+    rescue 
+      "It didn't work"
+    end
+
+    # Needs to be written like this:
+    return foo.message rescue "It didn't work!"

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Dana Scheider
+
+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,92 @@
+## ReactiveSupport [![Build Status](https://travis-ci.org/danascheider/reactive_support.svg?branch=master)](https://travis-ci.org/danascheider/reactive_support) [![Coverage Status](https://img.shields.io/coveralls/danascheider/reactive_support.svg)](https://coveralls.io/r/danascheider/reactive_support) [![Code Climate](https://codeclimate.com/github/danascheider/reactive_support/badges/gpa.svg)](https://codeclimate.com/github/danascheider/reactive_support) [![Inline docs](http://inch-ci.org/github/danascheider/reactive_support.svg?branch=master)](http://inch-ci.org/github/danascheider/reactive_support)
+The ReactiveSupport gem provides a re-implementation of certain [ActiveSupport](https://github.com/rails/activesupport)
+methods, allowing them to be used outside of the Rails ecosystem. This gem can 
+be used in any kind of project and is not dependent on any frameworks, gemsets, etc.
+To add ReactiveSupport to your project, add this to your Gemfile and run `bundle install`:
+<pre><code>gem 'reactive_record', '~> 0.1.0', git: 'https://github.com/danascheider/reactive_record'</code></pre>
+To install locally:
+<pre><code>sudo gem install reactive_record</code></pre>
+Or if you're using RVM: 
+<pre><code>gem install reactive_record</code></pre>
+Then, in your main project file, include:
+<pre><code>require 'reactive_support'</code></pre>
+
+### Usage
+In its current version, ReactiveSupport adds methods to Ruby's `Object` class, so
+once required, its methods can be used on any object within your project, including
+core Ruby classes.
+
+Currently, ReactiveSupport's methods are a strict subset of ActiveSupport's. (This may 
+change in future versions, or most saliently, if ActiveSupport's API changes.)
+That means that, while not all ActiveSupport methods are available, those that are can,
+as of September 2014, be found in ActiveSupport's API documentation with no functional
+differences. (This is true of ReactiveSupport 0.1.0 and ActiveSupport 4.1.6.)
+
+### FAQ
+##### Why not just use ActiveSupport?
+There are three main reasons why you might prefer ReactiveSupport over ActiveSupport:
+  1. Stability: ReactiveSupport is intended to work independently of Rails' rapidly changing 
+     ecosystem. ReactiveSupport methods are guaranteed not to be transferred to other
+     Rails modules or refactored out. While ActiveSupport may be used independently of
+     Rails, its developers are still primarily focused on its place within Rails.
+     ReactiveSupport solves that problem.
+  2. Simplicity: ReactiveSupport can be added to other projects without additional abstraction
+     layers, and it has no dependencies outside the development and test groups. You
+     don't have to worry about configuration, compatibility with other gems*, or
+     conflicting dependencies.
+  3. Transparency: Rails is an enormous gem, and gets larger and more complex with each major version.
+     It is also opinionated, facilitating some development approaches while making
+     others inordinately difficult. ReactiveSupport is not large or complicated. Any
+     developer can read the documentation, or even the code itself, and know exactly what
+     he or she is dealing with.
+
+\* I would not recommend using it in conjunction with ActiveSupport, though.
+
+##### This doesn't have very many methods. What gives?
+ReactiveSupport is a spinoff from my other project, [Canto](https://github.com/danascheider/canto).
+Consequently, the methods it includes are primarily those that I have found a use for 
+in Canto. As Canto grows, and as I have time, I will add more of ActiveSupport's 
+numerous useful methods to ReactiveSupport. In the meantime, I welcome contributions
+and will respond quickly to pull requests.
+
+##### Is ReactiveSupport being maintained?
+Yes. Since stability is one of the main advantages of ReactiveSupport, I will be taking
+an "if it ain't broke, don't fix it" approach to maintaining it. An absence of recent
+contributions should not be taken to mean it has fallen off my radar.
+
+##### Can I use ReactiveSupport in a Sinatra project/Puppet module/system utility/etc.?
+Yes. ReactiveSupport is agnostic to the characteristics of your app, and there is no
+reason it cannot be used in any app where you feel it is needed.
+
+##### What versions of Ruby are supported?
+ReactiveSupport version 0.1.0 supports Ruby versions >= 1.9.3. [Travis-CI](https://travis-ci.org/danascheider/reactive_support) is set up to run tests against the most recent version
+of JRuby as well (currently 1.7.16), but tests are currently failing and frankly, 
+I don't know JRuby well enough to fix them. Additional Rubies
+may be supported in the future. Adding such support would be a welcome contribution
+to the project.
+
+### Contributing
+Contributions are welcome and I will respond promptly to all issue reports and pull
+requests. Here are some guidelines to get started; I also encourage you to read the 
+full CONTRIBUTING.md file to ensure your pull request will be accepted as is:
+  * Include passing RSpec tests with your pull request. I aim for 100% test coverage.
+  * Run the whole test suite before you make your PR. Make sure your changes don't
+    break the rest of the gem.
+  * Make sure your changes are consistent with the functionality of ActiveSupport.
+    Users should be able to learn about a ReactiveSupport method by reading the 
+    ActiveSupport docs for the corresponding ActiveSupport method.
+  * Don't add any new dependencies to ReactiveSupport, or methods that are specific
+    to a particular framework, gemset, or type of app.
+  * Include documentation. ReactiveSupport uses [Inch CI](http://inch-ci.org) to
+    evaluate the quality of documentation. Please help make it easy for others to
+    use and contribute to this project.
+  * Keep ReactiveSupport principles - stability, simplicity, and transparency - in mind.
+    Ideally, contributions should uphold these principles while expanding or 
+    enhancing functionality.
+
+### Resources
+  * The [Rails guides](http://guides.rubyonrails.org/active_support_core_extensions.html) on
+    ActiveRecord give information about each of ReactiveSupport's methods.
+  * Those interested in contributing to ReactiveSupport are encouraged read up on 
+    [Travis CI](http://travis-ci.org), [Coveralls](http://coveralls.io), 
+    [CodeClimate](http://codeclimate.com), and [Inch CI](http://inch-ci.org).

data/files.rb

@@ -0,0 +1,19 @@
+module ReactiveSupport
+  def self.files
+    Files::FILES.flatten
+  end
+
+  module Files
+    LIB_FILES  = Dir.glob('./lib/**/*.rb').sort
+    BASE_FILES = %w(CONTRIBUTING.md 
+                    files.rb 
+                    LICENSE 
+                    Gemfile 
+                    README.md 
+                    reactive_support.gemspec 
+                    version.rb)
+    SPEC_FILES = Dir.glob('./spec/**/*.rb').sort
+
+    FILES = [BASE_FILES, LIB_FILES, SPEC_FILES]
+  end
+end

data/lib/extensions/reactive_extensions.rb

@@ -0,0 +1,41 @@
+require 'reactive_support'
+
+# The ReactiveAddOns module consists of methods I wish ActiveSupport provided.
+# These methods do not adhere to the ActiveSupport API. If you wish to include
+# them in your project, you will need to put this in your main project file:
+#     require 'reactive_support/extensions'
+#
+# ReactiveExtensions includes ReactiveSupport, so you will need to remove any 
+# requires for ReactiveSupport as it will raise a SystemStackError.
+
+module ReactiveExtensions
+
+  # The +#try_rescue+ method extends ReactiveSupport's +#try+ method so it
+  # rescues NoMethodErrors and TypeErrors as well as returning +nil+ when
+  # called on a +nil+ value.
+  #
+  # Like the +#try+ method, +#try_rescue+ takes 1 or more arguments. The first
+  # argument is the method to be called on the calling object, passed as a 
+  # symbol. The others are zero or more arguments that will be passed through to 
+  # that method, and +&block+ is an optional block that will be similarly passed through.
+  #
+  # Example of usage identical to +#try+:
+  #     nil.try(:map) {|a| a.to_s }           # => nil
+  #     nil.try_rescue(:map) {|a| a.to_s }    # => nil
+  #     
+  # Example of usage calling a method that is not defined on the calling object:
+  #     10.try(:to_h)           # => TypeError
+  #     10.try_rescue(:to_h)    # => nil
+  #
+  # Example of usage with invalid arguments:
+  #     %w(foo, bar, baz).try(:join, [:hello, :world])        # => TypeError
+  #     %w(foo, bar, baz).try_rescue(:join, [:hello, :world]) # => nil
+
+  def try_rescue(*args, &block)
+    self.try(*args, &block) rescue nil
+  end
+end
+
+class Object
+  include ReactiveExtensions
+end

data/lib/reactive_support/core_ext/array/access.rb

@@ -0,0 +1,34 @@
+class Array 
+
+  # The +#from+ method returns the tail of the array starting at the given 
+  # +position+.
+  #     [1, 2, 3, 4, 5].from(2)     # => [3, 4, 5]
+  #     [1, 2, 3, 4, 5].from(0)     # => [1, 2, 3, 4, 5]
+  #     [1, 2, 3, 4, 5].from(-2)    # => [4, 5]
+  #
+  # +#from+ returns an empty array if the receiving array is empty, the given
+  # +position+ exceeds the maximum index of the array, or the given +position+
+  # is lower than the array's minimum (i.e., largest negative) index.
+  #     [].from(0)                  # => []
+  #     [1, 2, 3, 4, 5].from(10)    # => []
+  #     [1, 2, 3, 4, 5].from(-10)   # => []
+
+  def from(position)
+    self[position, length] ||  []
+  end
+
+  # The +#to+ method returns the beginning of the array up to and including
+  # the given +position+.
+  #     [1, 2, 3, 4, 5].to(2)       # => [1, 2, 3]
+  #     [1, 2, 3, 4, 5].to(10)      # => [1, 2, 3, 4, 5]
+  #     [1, 2, 3, 4, 5].to(-2)      # => [1, 2, 3, 4]
+  #
+  # +#to+ returns an empty array if the receiving array is empty or the given 
+  # +position+ falls below the minimum (negative) index.
+  #     [].to(0)                    # => []
+  #     [1, 2, 3, 4, 5].to(-10)     # => []
+
+  def to(position)
+    self[0..position]
+  end
+end

data/lib/reactive_support/core_ext/object/blank.rb

@@ -0,0 +1,189 @@
+# This file adds the +#blank?+ and +#present?+ methods to core Ruby classes
+# The +#blank?+ method returns +true+ if the object is undefined, blank, false,
+# empty, or nil. The +#present?+ method returns the opposite of +#blank?+
+
+# Ruby's core String class. See documentation for version 
+# 2.1.3[http://ruby-doc.org/core-2.1.3/String.html],
+# 2.0.0[http://ruby-doc.org/core-2.1.3/String.html], or 
+# 1.9.3[http://ruby-doc.org/core-2.0.0/String.html].
+
+class String
+
+  # When called on a string, the +#blank?+ method returns +true+ if the string
+  # is empty or consists only of whitespace:
+  #     ''.blank?      # => true 
+  #     " \n ".blank?  # => true 
+  #     'foo'.blank?   # => false
+
+  def blank?
+    !!(/\A[[:space:]]*\z/ =~ self) || self.empty?
+  end
+
+  # When called on a string, the +#present?+ method returns +true+ unless the 
+  # string is empty or consists only of whitespace:
+  #     'foo'.present?  # => true 
+  #     ''.present?     # => false 
+  #     '   '.present?  # => false
+
+  def present?
+    !blank?
+  end
+end
+
+# Ruby's core Array class. See documentation for version 
+# 2.1.3[http://ruby-doc.org/core-2.1.3/FalseClass.html],
+# 2.0.0[http://ruby-doc.org/core-2.0.0/FalseClass.html], or 
+# 1.9.3[http://ruby-doc.org/core-1.9.3/FalseClass.html].
+
+class Array
+
+  # When called on an array, the +#blank?+ method is aliased to +#empty?+ 
+  # and returns +true+ when the array has no elements. Note that +#blank?+ 
+  # returns +false+ if the array has elements that are themselves all blank:
+  #     [].blank?               # => true
+  #     ['foo', 'bar'].blank?   # => false
+  #     [false, nil, ''].blank? # => false
+
+  alias_method :blank?, :empty?
+
+  # When called on an array, the +#present?+ method returns +true+ if the 
+  # array has any elements. Note that +#present?+ also returns +true+ if the
+  # array consists of blank values:
+  #     ['foo', 'bar'].present?    # => true 
+  #     [false, nil].present?      # => true 
+  #     [].present?                # => false
+
+  def present?
+    !blank?
+  end
+end
+
+# Ruby's core Hash class. See documentation for version 
+# 2.1.3[http://ruby-doc.org/core-2.1.3/Hash.html],
+# 2.0.0[http://ruby-doc.org/core-2.0.0/Hash.html], or 
+# 1.9.3[http://ruby-doc.org/core-1.9.3/Hash.html].
+
+class Hash
+
+  # When called on a hash (or any enumerable), the +#blank?+ method is aliased
+  # to +#empty?+ and as such returns +true+ if the hash is empty:
+  #     {}.blank?              # => true 
+  #     { foo: 'bar' }.blank?  # => false
+  #     { foo: nil }.blank?    # => false
+
+  alias_method :blank?, :empty?
+
+  # When called on a hash (or any enumerable), the +#present?+ method returns 
+  # +true+ if the hash is not empty, even if its elements have blank values:
+  #     { foo: :bar }.present?      # => true
+  #     { 'bar' => nil }.present?   # => true
+  #     {}.present?                 # => false
+
+  def present?
+    !blank?
+  end
+end
+
+# Ruby's core NilClass (the singleton class consisting of the +nil+ object). 
+# See documentation for version 2.1.3[http://ruby-doc.org/core-2.1.3/NilClass.html],
+# 2.0.0[http://ruby-doc.org/core-2.0.0/NilClass.html], or 
+# 1.9.3[http://ruby-doc.org/core-1.9.3/NilClass.html].
+
+class NilClass
+
+  # +nil+ is considered blank by definition; if +#blank?+ is called on +nil+,
+  # it will always return +true+:
+  #     nil.blank?        # => true
+  #
+  #     # When the +foo+ variable is undefined or set to nil:
+  #     foo.blank?        # => true
+
+  def blank?
+    true
+  end
+
+  # Likewise, +nil+ is not present by definition; if +#present?+ is called on 
+  # +nil+, it will always return +false+:
+  #     nil.present?      # => false
+  # 
+  #     # When the +foo+ variable is undefined or set to nil:
+  #     foo.present?      # => false
+
+  def present?
+    false
+  end
+end
+
+# Ruby's core TrueClass (the singleton class consisting of the +true+ object).
+# See documentation for version 2.1.3[http://ruby-doc.org/core-2.1.3/TrueClass.html],
+# 2.0.0[http://ruby-doc.org/core-2.0.0/TrueClass.html], or 
+# 1.9.3[http://ruby-doc.org/core-1.9.3/TrueClass.html].
+
+class TrueClass
+
+  # +true+ is not blank by definition; when called on +true+, the +#blank?+
+  # method will return +false+:
+  #     true.blank?   # => false
+
+  def blank?
+    false
+  end
+
+  # +true+ is present by definition; when called on +true+, the +#present?+
+  # method will return +true+:
+  #     true.present?   # => true
+
+  def present?
+    true 
+  end
+end
+
+# Ruby's core FalseClass (the singleton class consisting of the +false+ object).
+# See documentation for version 2.1.3[http://ruby-doc.org/core-2.1.3/FalseClass.html],
+# 2.0.0[http://ruby-doc.org/core-2.0.0/FalseClass.html], or 
+# 1.9.3[http://ruby-doc.org/core-1.9.3/FalseClass.html].
+
+class FalseClass
+
+  # +false+ is blank by definition; when called on +false+, the +#blank?+
+  # method will return +true+:
+  #     false.blank?    # => true 
+
+  def blank?
+    true
+  end
+
+  # +false+ is not present by definition; when called on +false+, the +#present?+
+  # method will return +false+:
+  #     false.present?    # => false
+
+  def present? 
+    false 
+  end
+end
+
+# Ruby's core Numeric class, the parent class of Integer, Fixnum, Bignum, Float,
+# and Rational. See documentation for version 2.1.3[http://ruby-doc.org/core-2.1.3/Numeric.html],
+# 2.0.0[http://ruby-doc.org/core-2.0.0/Numeric.html], or 
+# 1.9.3[http://ruby-doc.org/core-1.9.3/Numeric.html].
+
+class Numeric 
+
+  # Numbers can never be blank; when called on any +Numeric+ (including +Fixnum+,
+  # +Bignum+, +Float+, +Integer+, and +Rational+), the +#blank?+ method will
+  # return +false+:
+  #     10.blank?     # => false
+
+  def blank?
+    false 
+  end
+
+  # Numbers are always present; when called on any +Numeric+ (including +Fixnum+,
+  # +Bignum+, +Float+, +Integer+, and +Rational+), the +#present?+ method will
+  # return +true+:
+  #     Math.PI.present?    # => true
+
+  def present? 
+    true 
+  end
+end

data/lib/reactive_support/core_ext/object/deep_dup.rb

@@ -0,0 +1,54 @@
+class Object
+  
+  # The +#deep_dup+ method returns a duplicate of a duplicable object. If the 
+  # object calling +#deep_dup+ is not duplicable, the object itself is returned.
+  # +#deep_dup+ is overwritten in the Array and Hash classes (see +./object/deep_dup.rb+).
+  # In those classes, it duplicates the object recursively so the members of the
+  # enumerable can be manipulated without affecting the original object.
+
+  def deep_dup
+    duplicable? ? self.dup : self
+  end
+end
+
+class Array
+
+  # When called on an array, the +#deep_dup+ method duplicates all the members
+  # of the array recursively, so that actions on the duplicate do not affect 
+  # the original:
+  #
+  #     arr = [1, 2, [3, 4]]                  # => [1, 2, [3, 4]]
+  #     dup, deep = arr.dup, arr.deep_dup     # => [1, 2, [3, 4]], [1, 2, [3, 4]]
+  #     
+  #     deep[2][1] = 5                        # => [1, 2, [3, 5]]
+  #     p arr                                 # => [1, 2, [3, 4]]
+  #
+  #     dup[2][1] = 5                         # => [1, 2, [3, 5]]
+  #     p arr                                 # => [1, 2, [3, 5]]
+
+  def deep_dup
+    self.map {|item| item.deep_dup }
+  end
+end
+
+class Hash 
+
+  # When called on a hash, the +#deep_dup+ method duplicates all the key-value
+  # pairs in the hash recursively, so that actions on the duplicate do not affect
+  # the original hash:
+  #
+  # hash = {a: {b: 2}}                        # => {a: {b: 2}}
+  # dup, deep = hash.dup, hash.deep_dup       # => {a: {b: 2}}, {a: {b: 2}}
+  #
+  # deep[:a][:b] = 14                         # => {a: {b: 14}}
+  # p hash                                    # => {a: {b: 2}}
+  #
+  # dup[:a][:b] = 14                          # => {a: {b: 14}}
+  # p hash                                    # => {a: {b: 14}}
+
+  def deep_dup
+    self.each_with_object(dup) do |(key, value), hash|
+      hash[key.deep_dup] = value.deep_dup
+    end
+  end
+end

data/lib/reactive_support/core_ext/object/duplicable.rb

@@ -0,0 +1,39 @@
+class Object
+
+  # The +#duplicable?+ method checks whether an object may be safely duplicated.
+  # It returns true, unless the object calling it has its own method called 
+  # +#duplicable?+. The +#duplicable?+ method is defined for non-duplicable
+  # classes in +./object/duplicable.rb+.
+
+  def duplicable?
+    true
+  end
+end
+
+# Define +#duplicable?+ for all of the classes in the array.
+
+[NilClass, FalseClass, TrueClass, Method, Symbol, Numeric].each do |klass|
+  klass.class_eval do 
+    def duplicable?
+      false 
+    end
+  end
+end
+
+require 'bigdecimal'
+
+# BigDecimal class from Ruby's standard library. See documentation for version
+# 2.1.3[http://www.ruby-doc.org/stdlib-2.1.3/libdoc/bigdecimal/rdoc/BigDecimal.html],
+# 2.0.0[http://ruby-doc.org/stdlib-2.0.0/libdoc/bigdecimal/rdoc/BigDecimal.html], or
+# 1.9.3[http://www.ruby-doc.org/stdlib-1.9.3/libdoc/bigdecimal/rdoc/BigDecimal.html].
+
+class BigDecimal
+
+  # This is required for compatibility with Ruby 1.9.x. In Ruby 1.9.x, 
+  # +dup+ is not allowed on a BigDecimal and raises a TypeError. Rescue
+  # the type error to simply return false.
+
+  def duplicable?
+    !!self.dup rescue super
+  end
+end