reactive_support 0.4.0.beta3 → 0.5.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe11b1fd5e03c2c900cb98199ab88a1021ccec3d
-  data.tar.gz: 30b5b284b8e8002f14d35ba3fbc27e97f63db263
+  metadata.gz: e484324b27a831addea4d4f31a5a4343219dae84
+  data.tar.gz: 69b6a58c8ab40a915a92f6f2f87da0719edf918a
 SHA512:
-  metadata.gz: 5fc1a35572ccdf4905584c078fb81897e13ac270355c934a75997c09af7fc7db1e8533ecded5a1b50ea9d4a4aa2e5625343335c9ab69d54d9da9edccf45ed4fa
-  data.tar.gz: 70b173a264c284d70033ec7d67d3eb96ca7d12d6535de6c03de2c674782b80d17f80a8acec548c78394335bfabfdae693117b0468cb8684459a14bca0602fa6c
+  metadata.gz: 273d1eaf8a1db8b34e9b0e71dc08fd8af31ef0d6d4f4fa408d53d37d87e3e49a2e84bc8b17a51c459bf5458958fbbf662f8d4ad6f5c8a929a1d6bcb7dce9562c
+  data.tar.gz: c114dca660f79679fdb6a59ac7d6ca866c6a9806cf76492f88aa6a7ff1d307fa88f936272eec3b2f493d5f21e0f675abc346c8828a0aaa8bb64ed9b32d9757f5

data/lib/reactive_support/core_ext/array.rb

@@ -0,0 +1 @@
+Dir['./lib/reactive_support/core_ext/array/*.rb'].each {|f| require f }

data/lib/reactive_support/core_ext/hash/keys.rb

@@ -0,0 +1,154 @@
+# This file adds the +#transform_keys+, +#transform_keys!+,
+# +#stringify_keys+, +#stringify_keys!+, +#symbolize_keys+, and 
+# +#symbolize_keys! methods to Ruby's core +Hash+ class. These
+# methods modify the hash's keys according to given parameters,
+# or create a duplicate with keys modified in this way.
+
+# Ruby's core Hash class. See documentation for version 
+# 2.1.5[http://ruby-doc.org/core-2.1.5/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
+
+  # The +#assert_valid_keys method validates that all keys in a hash 
+  # match +*valid_keys+, raising an ArgumentError if the keys don't
+  # match. Note that, as usual, symbols and strings are treated as 
+  # distinct.
+  #
+  # Examples:
+  #     {:foo => 'bar'}.assert_valid_keys(:foo)         # => true
+  #     {:foo => 'bar'}.assert_valid_keys(:foo, :baz)   # => true
+  #     {:foo => 'bar'}.assert_valid_keys(:baz)         # => ArgumentError
+  #     {:foo => 'bar'}.assert_valid_keys('foo')        # => ArgumentError
+
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+    each_key do |key|
+      unless valid_keys.include?(key) 
+        raise ArgumentError.new("Unknown key: #{key.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
+      end
+    end
+  end
+
+  # The +#stringify_keys+ method returns a hash identical to the calling
+  # hash, but with symbol keys turned into strings. It is non-destructive;
+  # the original hash is still available after it is called.
+  #
+  # Although this method was formerly a part of ActiveSupport, it was
+  # already deprected by the time ReactiveSupport was introduced. For
+  # that reason, it is being included as part of ReactiveExtensions.
+  #
+  # Examples: 
+  #     orig = { :foo => 'bar' }
+  #     dup = orig.stringify_keys
+  # 
+  #     orig      #=> { :foo => 'bar' }
+  #     dup       #=> { 'foo' => 'bar' }
+
+  def stringify_keys
+    transform_keys &:to_s
+  end
+
+  # The +#stringify_keys!+ method converts symbol hash keys into strings.
+  # It is a destructive method; the original hash is changed when this
+  # method is called.
+  #
+  # Although this method was formerly a part of ActiveSupport, it was already
+  # deprecated by the time ReactiveSupport was introduced. For that reason,
+  # it is being included as part of ReactiveExtensions.
+  #
+  # Examples:
+  #     orig = { :foo => 'bar' }
+  #     orig.symbolize_keys!
+  #
+  #     orig      #=> { 'foo' => 'bar' }
+
+  def stringify_keys!
+    transform_keys! &:to_s
+  end
+
+  # The +#symbolize_keys+ method returns a hash identical to the calling
+  # hash but with string keys turned into symbols. It is non-destructive;
+  # the original hash is still available after it is called.
+  #
+  # Although this method was formerly a part of ActiveSupport, it was 
+  # already deprecated by the time ReactiveSupport was introduced. For
+  # that reason, it is being included as part of ReactiveExtensions.
+  #
+  # Examples:
+  #     orig = { 'foo' => 'bar' }
+  #     dup = orig.symbolize_keys
+  #
+  #     orig      #=> { 'foo' => 'bar' }
+  #     dup       #=> { :foo => 'bar' }
+
+  def symbolize_keys
+    transform_keys {|key| key.to_sym }
+  end
+
+  # The +#symbolize_keys!+ method converts string hash keys into symbols.
+  # It is a destructive method; the original hash is changed when this
+  # method is called.
+  #
+  # Although this method was formerly a part of ActiveSupport, it was already
+  # deprecated by the time ReactiveSupport was introduced. For that reason,
+  # it is being included as part of ReactiveExtensions.
+  #
+  # Examples:
+  #     orig = { 'foo' => 'bar' }
+  #     orig.symbolize_keys!
+  #
+  #     orig      #=> { :foo => 'bar' }
+
+  def symbolize_keys!
+    transform_keys! {|key| key.to_sym }
+  end
+
+  # The +#transform_keys+ method returns a new hash with all keys transformed
+  # in accordance with the given +block+. The +#transform_keys+ method is 
+  # non-destructive; the original hash will still be available after it is 
+  # called.
+  #
+  # If no block is given, the method returns an enumerator. 
+  # 
+  # Example:
+  #     hash = { :foo => 'bar' }
+  #     hash.transform_keys {|key| key.to_s.upcase }      # => { 'FOO' => 'bar' }
+  #     hash.transform_keys                               # => #<Enumerator: {:foo=>"bar"}:transform_keys>
+  #     hash                                              # => { :foo => 'bar' }
+
+  def transform_keys(&block)
+    return enum_for(:transform_keys) unless block_given?
+    dup = self.class.new 
+
+    each_key do |key|
+      dup[yield key] = self[key]
+    end
+
+    dup
+  end
+
+  # The +#transform_keys!+ method transforms all of the calling hash's keys
+  # in accordance with the given +block+. The +#transform_keys!+ method is 
+  # destructive; the original hash will be changed in place after it is 
+  # called.
+  #
+  # If no block is given, the method returns an enumerator. 
+  # 
+  # Example:
+  #     hash = { :foo => 'bar' }
+  #     hash.transform_keys! {|key| key.to_s.upcase }     # => { 'FOO' => 'bar' }
+  #     hash.transform_keys!                              # => #<Enumerator: {:foo=>"bar"}:transform_keys!>
+  #     hash                                              # => { 'FOO' => 'bar' }
+
+  def transform_keys!(&block)
+    return enum_for(:transform_keys) unless block_given?
+
+    keys.each do |key|
+      self[yield key] = delete(key)
+    end
+
+    self
+  end
+end

data/lib/reactive_support/core_ext/hash.rb

@@ -0,0 +1 @@
+Dir['./lib/reactive_support/core_ext/hash/*.rb'].each {|f| require f }

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

@@ -1,3 +1,5 @@
+require 'reactive_support/core_ext/object/duplicable'
+
 # Ruby's core Object class. See documentation for version 
 # 2.1.3[http://ruby-doc.org/core-2.1.3/Object.html],
 # 2.0.0[http://ruby-doc.org/core-2.1.3/Object.html], or 

data/lib/reactive_support/core_ext/object.rb

@@ -0,0 +1 @@
+Dir['./lib/reactive_support/core_ext/object/*.rb'].each {|f| require f }

data/lib/reactive_support/core_ext.rb

@@ -0,0 +1 @@
+Dir['./lib/reactive_support/core_ext/**/*.rb'].each {|f| require f }

data/lib/reactive_support.rb

@@ -1,5 +1,4 @@
-Dir['./lib/reactive_support/core_ext/**/*.rb'].each {|f| require f }
-Dir['./lib/reactive_support/extensions/**/*.rb'].each {|f| require f }
+Dir['./lib/reactive_support/*.rb'].each {|f| require f }
 
 # The ReactiveSupport module implements methods from ActiveSupport. It can be
 # included in Ruby's +Object+ class by adding +require 'reactive_support'+ to
@@ -8,6 +7,7 @@ Dir['./lib/reactive_support/extensions/**/*.rb'].each {|f| require f }
 # 
 # In this example, ReactiveSupport's #try method is called on an array:
 #     require 'reactive_support'
+#     require 'reactive_support/core_ext/array/try'
 #     
 #     arr = %w(foo, bar, baz)
 #     arr.try(:join, '.') 

data/reactive_support.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
 
   s.name                      = 'reactive_support'
   s.version                   = ReactiveSupport.gem_version
-  s.date                      = '2014-11-27'
+  s.date                      = '2014-11-28'
 
   s.description = "ActiveSupport methods re-implemented independently of the Rails ecosystem"
   s.summary     = "ReactiveSupport provides useful ActiveSupport methods in a gem that is simple, stable, agnostic, and transparent."
@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
 
   # = MANIFEST =
   s.files                     = ReactiveSupport.files
-  s.require_path              = 'lib'
+  s.require_paths             = ['lib']
   # = MANIFEST =
 
   s.test_files                = s.files.select {|path| path =~ /^spec\/.*.rb/ }

data/spec/hash_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Hash do 
+  let(:hash) { { :foo => 'bar', :baz => 'qux' } }
+
+  describe 'assert_valid_keys' do 
+    context 'all keys are valid' do 
+      it 'returns the hash' do 
+        expect(hash.assert_valid_keys(:foo, :baz)).to eql hash
+      end
+
+      it 'doesn\'t raise an error' do 
+        expect{ hash.assert_valid_keys(:foo, :baz) }.not_to raise_error
+      end
+    end
+
+    context 'keys are a subset of valid keys' do 
+      it 'returns the hash' do 
+        expect(hash.assert_valid_keys(:foo, :bar, :baz)).to eql hash
+      end
+
+      it 'doesn\'t raise an error' do 
+        expect{ hash.assert_valid_keys(:foo, :bar, :baz) }.not_to raise_error
+      end
+    end
+
+    context 'keys are wrong type' do 
+      it 'raises an ArgumentError' do 
+        expect{ hash.assert_valid_keys(:foo, 'baz') }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'invalid keys are present' do 
+      it 'raises an ArgumentError' do 
+        expect{ hash.assert_valid_keys(:foo, 'baz') }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe 'stringify_keys' do 
+    it 'turns symbol keys into strings' do 
+      expect(hash.stringify_keys).to eql({'foo' => 'bar', 'baz' => 'qux'})
+    end
+
+    it 'maintains the original hash' do 
+      expect { hash.stringify_keys }.not_to change(hash, :keys)
+    end
+  end
+
+  describe 'stringify_keys!' do 
+    it 'turns symbol keys into strings' do 
+      expect(hash.stringify_keys!).to eql({'foo' => 'bar', 'baz' => 'qux'})
+    end
+
+    it 'overwrites the original hash' do
+      expect { hash.stringify_keys! }.to change(hash, :keys)
+    end
+  end
+
+  describe 'symbolize_keys' do 
+    let(:hash) { {'foo' => 'bar' } }
+
+    it 'turns string keys into symbols' do 
+      expect(hash.symbolize_keys).to eql({:foo => 'bar'})
+    end
+
+    it 'maintains the original hash' do 
+      expect { hash.symbolize_keys }.not_to change(hash, :keys)
+    end
+  end
+
+  describe 'symbolize_keys!' do 
+    let(:hash) { {'foo' => 'bar' } }
+
+    it 'turns string keys into symbols' do 
+      expect(hash.symbolize_keys!).to eql({:foo => 'bar'})
+    end
+
+    it 'overwrites the original hash' do
+      expect{ hash.symbolize_keys! }.to change(hash, :keys)
+    end
+  end
+
+  describe 'transform_keys' do  
+    it 'changes keys according to a block' do 
+      transformed = hash.transform_keys {|key| key.to_s.upcase }
+      expect(transformed).to eql({'FOO' => 'bar', 'BAZ' => 'qux'})
+    end
+
+    it 'is non-destructive' do 
+      expect{ hash.transform_keys {|key| key.to_s.upcase } }.not_to change(hash, :keys)
+    end
+
+    context 'no block given' do 
+      it 'returns an enumerator' do 
+        expect(hash.transform_keys).to be_an(Enumerator)
+      end
+    end
+  end
+
+  describe 'transform_keys!' do  
+    it 'changes keys according to a block' do 
+      transformed = hash.transform_keys! {|key| key.to_s.upcase }
+      expect(transformed).to eql({'FOO' => 'bar', 'BAZ' => 'qux'})
+    end
+
+    it 'is destructive' do 
+      expect{ hash.transform_keys! {|key| key.to_s.upcase } }.to change(hash, :keys)
+    end
+
+    context 'no block given' do 
+      it 'returns an enum' do 
+        expect(hash.transform_keys!).to be_an(Enumerator)
+      end
+    end
+  end
+end

data/version.rb

@@ -5,9 +5,9 @@ module ReactiveSupport
 
   module Version
     MAJOR = '0'
-    MINOR = '4'
+    MINOR = '5'
     PATCH = '0'
-    PRE   = 'beta3'
+    PRE   = 'beta'
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.').chomp('.')
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reactive_support
 version: !ruby/object:Gem::Version
-  version: 0.4.0.beta3
+  version: 0.5.0.beta
 platform: ruby
 authors:
 - Dana Scheider
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-27 00:00:00.000000000 Z
+date: 2014-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -76,7 +76,12 @@ extra_rdoc_files:
 - LICENSE
 files:
 - "./lib/reactive_support.rb"
+- "./lib/reactive_support/core_ext.rb"
+- "./lib/reactive_support/core_ext/array.rb"
 - "./lib/reactive_support/core_ext/array/access.rb"
+- "./lib/reactive_support/core_ext/hash.rb"
+- "./lib/reactive_support/core_ext/hash/keys.rb"
+- "./lib/reactive_support/core_ext/object.rb"
 - "./lib/reactive_support/core_ext/object/blank.rb"
 - "./lib/reactive_support/core_ext/object/deep_dup.rb"
 - "./lib/reactive_support/core_ext/object/duplicable.rb"
@@ -84,13 +89,8 @@ files:
 - "./lib/reactive_support/core_ext/object/inclusion.rb"
 - "./lib/reactive_support/core_ext/object/instance_variables.rb"
 - "./lib/reactive_support/core_ext/object/try.rb"
-- "./lib/reactive_support/extensions/array_extensions.rb"
-- "./lib/reactive_support/extensions/hash_extensions.rb"
-- "./lib/reactive_support/extensions/object_extensions.rb"
-- "./lib/reactive_support/extensions/proc_extensions.rb"
-- "./lib/reactive_support/extensions/reactive_extensions.rb"
 - "./spec/array_spec.rb"
-- "./spec/reactive_extensions_spec.rb"
+- "./spec/hash_spec.rb"
 - "./spec/reactive_support_spec.rb"
 - "./spec/spec_helper.rb"
 - CONTRIBUTING.md

data/lib/reactive_support/extensions/array_extensions.rb

@@ -1,51 +0,0 @@
-class Array
-  
-  # The +#scope+ method is called on an array of hashes. It returns a sub-array
-  # including only hashes for which the value at a given +key+ is among the given +values+.
-  # The +#scope+ method is non-destructive; the original array will remain intact
-  # after it is called. The +#scope+ method is known to work for string or symbol
-  # keys. It should work for other data type keys as well.
-  #
-  # Example:
-  #     array = [
-  #       { name: 'Jean-Paul Sartre', nationality: 'French' },
-  #       { name: 'Bertrand Russell', nationality: 'English' },
-  #       { name: 'Ludwig Wittgenstein', nationality: 'Austrian' },
-  #       { name: 'Albert Camus', nationality: 'French' }
-  #     ]
-  # 
-  #     array.scope(:nationality, 'French')
-  #       # => [
-  #              { name: 'Jean-Paul Sartre', nationality: 'French' },
-  #              { name: 'Albert Camus', nationality: 'French' }
-  #            ]
-
-  def scope(key, *values)
-    self.select {|hash| hash[key].in?(values) }
-  end
-
-  # The +#where_not+ method is called on an array of hashes. It returns a sub-array
-  # including only hashes for which the value at a given +key+ is not among the
-  # given +values+. It is the inverse of the +#scope+ method. The +#where_not+ method 
-  # is non-destructive; the original array will remain intact after it is called. The
-  # +#where_not+ method is known to work for string or symbol keys. It should work for
-  # other data types as well.
-  #
-  # Example:
-  #     array = [
-  #       { name: 'Jean-Paul Sartre', nationality: 'French' },
-  #       { name: 'Bertrand Russell', nationality: 'English' },
-  #       { name: 'Ludwig Wittgenstein', nationality: 'Austrian' },
-  #       { name: 'Albert Camus', nationality: 'French' }
-  #     ]
-  # 
-  #     array.where_not(:nationality, 'French')
-  #       # => [
-  #              { name: 'Bertrand Russell', nationality: 'English' },
-  #              { name: 'Ludwig Wittgenstein', nationality: 'English' }
-  #            ]
-
-  def where_not(key, *values)
-    self.reject {|hash| hash[key].in?(values) }
-  end
-end

data/lib/reactive_support/extensions/hash_extensions.rb

@@ -1,135 +0,0 @@
-class Hash
-
-  # The +#clean+ method returns a hash identical to the calling hash but
-  # with the given +*keys+, if present, removed. If all the keys in the
-  # hash are given as arguments, an empty hash is returned. The +#clean+ 
-  # method is non-destructive; the original hash is still available after 
-  # it is called. It does have a destructive form, +#clean!+.
-  # 
-  # Examples:
-  #     hash = {:foo => 'bar'}
-  #     hash.clean(:baz)          # => {:foo => 'bar'}
-  #     hash.clean(:foo)          # => {}
-  #     hash                      # => {:foo => 'bar'}
-  #
-  # Examples with multiple arguments:
-  #     hash = { 'foo' => 'bar', 'baz' => 'qux', => :norf => 'raboof' }
-  #     hash.clean('foo', :norf)  # => {'baz' => 'qux'}
-  #     hash                      # => { 'foo' => 'bar', 'baz' => 'qux', :norf => 'raboof' }
-
-  def clean(*keys)
-    self.reject {|k,v| k.in?(keys) }
-  end
-
-  # The +#clean!+ method returns a hash identical to the calling hash but
-  # with the given +*keys+, if present, removed. If all the keys in the
-  # hash are given as arguments, an empty hash is returned. The +#clean!+ 
-  # method is non-destructive; the original hash is still available after 
-  # it is called. It does have a non-destructive form, +#clean+.
-  # 
-  # Examples where hash is not changed:
-  #     hash = {:foo => 'bar'}
-  #     hash.clean!(:baz)         # => {:foo => 'bar'}
-  #     hash                      # => {:foo => 'bar'}
-  #
-  # Examples where hash is changed: 
-  #     hash = {'foo' => 'bar'}
-  #     hash.clean!(:foo)         # => {}
-  #     hash                      # => {}
-  #
-  # Examples with multiple arguments:
-  #     hash = { 'foo' => 'bar', 'baz' => 'qux', => :norf => 'raboof' }
-  #     hash.clean('foo', :norf)  # => {'baz' => 'qux'}
-  #     hash                      # => {'baz' => 'qux'}
-
-  def clean!(*keys)
-    self.reject! {|k,v| k.in?(keys) }
-    self
-  end
-
-  # The +#symbolize_keys+ method returns a hash identical to the calling
-  # hash but with string keys turned into symbols. It is non-destructive;
-  # the original hash is still available after it is called.
-  #
-  # Although this method was formerly a part of ActiveSupport, it was 
-  # already deprecated by the time ReactiveSupport was introduced. For
-  # that reason, it is being included as part of ReactiveExtensions.
-  #
-  # Examples:
-  #     orig = { 'foo' => 'bar' }
-  #     dup = orig.symbolize_keys
-  #
-  #     orig      #=> { 'foo' => 'bar' }
-  #     dup       #=> { :foo => 'bar' }
-
-  def symbolize_keys
-    dup = {}
-    self.each {|k, v| dup[k.to_sym] = v }
-    dup
-  end
-
-  # The +#symbolize_keys!+ method converts string hash keys into symbols.
-  # It is a destructive method; the original hash is changed when this
-  # method is called.
-  #
-  # Although this method was formerly a part of ActiveSupport, it was already
-  # deprecated by the time ReactiveSupport was introduced. For that reason,
-  # it is being included as part of ReactiveExtensions.
-  #
-  # Examples:
-  #     orig = { 'foo' => 'bar' }
-  #     orig.symbolize_keys!
-  #
-  #     orig      #=> { :foo => 'bar' }
-
-  def symbolize_keys!
-    keys.each do |key|
-      self[(key.to_sym rescue key) || key] = delete(key)
-    end
-
-    self
-  end
-
-  # The +#stringify_keys+ method returns a hash identical to the calling
-  # hash, but with symbol keys turned into strings. It is non-destructive;
-  # the original hash is still available after it is called.
-  #
-  # Although this method was formerly a part of ActiveSupport, it was
-  # already deprected by the time ReactiveSupport was introduced. For
-  # that reason, it is being included as part of ReactiveExtensions.
-  #
-  # Examples: 
-  #     orig = { :foo => 'bar' }
-  #     dup = orig.stringify_keys
-  # 
-  #     orig      #=> { :foo => 'bar' }
-  #     dup       #=> { 'foo' => 'bar' }
-
-  def stringify_keys
-    dup = {}
-    self.each {|k, v| dup[k.to_s] = v }
-    dup
-  end
-
-  # The +#stringify_keys!+ method converts symbol hash keys into strings.
-  # It is a destructive method; the original hash is changed when this
-  # method is called.
-  #
-  # Although this method was formerly a part of ActiveSupport, it was already
-  # deprecated by the time ReactiveSupport was introduced. For that reason,
-  # it is being included as part of ReactiveExtensions.
-  #
-  # Examples:
-  #     orig = { :foo => 'bar' }
-  #     orig.symbolize_keys!
-  #
-  #     orig      #=> { 'foo' => 'bar' }
-
-  def stringify_keys!
-    keys.each do |key|
-      self[(key.to_s rescue key) || key] = delete(key)
-    end
-
-    self
-  end
-end

data/lib/reactive_support/extensions/object_extensions.rb

@@ -1,48 +0,0 @@
-class Object
-
-  # 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
-
-# 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 an 
-# optional block to be likewise passed through.
-#
-# When called on NilClass, +#try_rescue+ always returns nil.
-#
-# Example:
-#     foo = nil 
-#     foo.try_rescue(:has_key?, :bar)     # => nil
-
-class NilClass
-  def try_rescue(*args, &block)
-    nil 
-  end
-end

data/lib/reactive_support/extensions/proc_extensions.rb

@@ -1,29 +0,0 @@
-# Ruby's core Proc class. See documentation for version 
-# 2.1.5[http://ruby-doc.org/core-2.1.5/Proc.html],
-# 2.0.0[http://ruby-doc.org/core-2.0.0/Proc.html], or 
-# 1.9.3[http://ruby-doc.org/core-1.9.3/Proc.html].
-
-class Proc
-
-  # The +#raises_error?+ method checks whether an exception is raised
-  # when the calling Proc is called with the given +*args+.
-  #
-  # The +#raises_error?+ method does not actually create lasting changes
-  # to objects or variables; it only checks whether an exception would be
-  # raised if the Proc were called with the given +*args+.
-  #
-  # Basic examples:
-  #     proc = Proc.new {|q| 1.quo(q) }
-  #     proc.raises_error?(2)       # => false
-  #     proc.raises_error?(0)       # => true
-  #
-  # Examples with destructive proc:
-  #     hash = {:foo => :bar}
-  #     proc = Proc.new {|hash| hash.reject! {|k,v| k === :foo } }
-  #     proc.raises_error?(hash)    # => false
-  #     hash                        # => {:foo => :bar}
-
-  def raises_error?(*args)
-    (!self.call(*args.deep_dup)) rescue true
-  end
-end

data/lib/reactive_support/extensions/reactive_extensions.rb

@@ -1,12 +0,0 @@
-
-# The ReactiveExtensions 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
-  Dir['./lib/reactive_support/extensions/*.rb'].each {|f| require f }
-end

data/spec/reactive_extensions_spec.rb

@@ -1,246 +0,0 @@
-require 'spec_helper'
-
-describe ReactiveExtensions do 
-  describe '#try_rescue method' do 
-    context 'when self is nil' do 
-      it 'returns nil' do 
-        expect(nil.try_rescue(:collect) {|i| i + 2 }).to eql nil
-      end
-    end
-
-    context 'when the method can be executed successfully' do 
-      it 'calls the method' do 
-        expect('foo'.try_rescue(:upcase)).to eql 'FOO'
-      end
-    end
-
-    context 'when a NoMethodError is raised' do 
-      it 'returns nil' do 
-        expect(('foo').try_rescue(:bar)).to eql nil
-      end
-    end
-  end
-
-  describe 'array methods' do 
-    let(:sartre) { { 'name' => 'Jean-Paul Sartre', 'nationality' => 'French' } }
-    let(:russell) { { 'name' => 'Bertrand Russell', 'nationality' => 'English' } }
-    let(:wittgenstein) { { 'name' => 'Ludwig Wittgenstein', 'nationality' => 'Austrian' } }
-    let(:camus) { { 'name' => 'Albert Camus', 'nationality' => 'French' } }
-    let(:array) { [sartre, russell, wittgenstein, camus] }
-
-    describe 'array #scope method' do 
-      context 'symbol keys' do
-        context 'single value' do 
-          it 'returns scoped hashes' do 
-            array.each {|hash| hash.symbolize_keys! }
-            expect(array.scope(:nationality, 'French')).to eql([sartre, camus])
-          end
-        end
-
-        context 'multiple values' do 
-          it 'returns scoped hashes' do 
-            array.each {|hash| hash.symbolize_keys! }
-            expect(array.scope(:nationality, 'French', 'English')).to eql([sartre, russell, camus])
-          end
-        end
-      end
-
-      context 'string keys' do
-        context 'single value' do 
-          it 'returns scoped hashes' do 
-            expect(array.scope('nationality', 'French')).to eql([sartre, camus])
-          end
-        end
-
-        context 'multiple values' do 
-          it 'returns scoped hashes' do 
-            expect(array.scope('nationality', 'French', 'English')).to eql([sartre, russell, camus])
-          end
-        end
-      end
-    end
-
-    describe 'array #where_not method' do 
-      context 'symbol keys' do 
-        context 'single value' do 
-          it 'returns scoped hashes' do 
-            array.each {|hash| hash.symbolize_keys! }
-            expect(array.where_not(:nationality, 'French')).to eql([russell, wittgenstein])
-          end
-        end
-
-        context 'multiple values' do 
-          it 'returns scoped hashes' do 
-            array.each {|hash| hash.symbolize_keys! }
-            expect(array.where_not(:nationality, 'French', 'English')).to eql([wittgenstein])
-          end
-        end
-      end
-
-      context 'string keys' do
-        context 'single value' do 
-          it 'returns scoped hashes' do 
-            expect(array.where_not('nationality', 'French')).to eql([russell, wittgenstein])
-          end
-        end
-
-        context 'multiple values' do 
-          it 'returns scoped hashes' do 
-            expect(array.where_not('nationality', 'French', 'English')).to eql([wittgenstein])
-          end
-        end
-      end
-    end
-  end
-
-  describe 'hash methods' do 
-    describe 'symbolize_keys' do 
-      it 'turns string keys into symbols' do 
-        expect({'foo' => 'bar'}.symbolize_keys).to eql({:foo => 'bar'})
-      end
-
-      it 'maintains the original hash' do 
-        hash = { 'foo' => 'bar' }
-        expect { hash.symbolize_keys }.not_to change(hash, :keys)
-      end
-    end
-
-    describe 'symbolize_keys!' do 
-      it 'turns string keys into symbols' do 
-        expect({'foo' => 'bar'}.symbolize_keys!).to eql({:foo => 'bar'})
-      end
-
-      it 'overwrites the original hash' do
-        hash = { 'foo' => 'bar' }
-        expect { hash.symbolize_keys! }.to change(hash, :keys)
-      end
-    end
-
-    describe 'stringify_keys' do 
-      it 'turns symbol keys into strings' do 
-        expect({foo: 'bar'}.stringify_keys).to eql({'foo' => 'bar'})
-      end
-
-      it 'maintains the original hash' do 
-        hash = { foo: 'bar' }
-        expect { hash.stringify_keys }.not_to change(hash, :keys)
-      end
-    end
-
-    describe 'stringify_keys!' do 
-      it 'turns symbol keys into strings' do 
-        expect({foo: 'bar'}.stringify_keys!).to eql({'foo' => 'bar'})
-      end
-
-      it 'overwrites the original hash' do
-        hash = { foo: 'bar' }
-        expect { hash.stringify_keys! }.to change(hash, :keys)
-      end
-    end
-
-    describe 'clean' do 
-      context 'when no cleaning is needed' do 
-        it 'returns the original hash' do 
-          expect({:foo => 'bar'}.clean(:baz)). to eql({:foo => 'bar'})
-        end
-
-        it 'doesn\'t raise an error' do 
-          expect{ {:foo => 'bar'}.clean(:baz) }.not_to raise_error
-        end
-      end
-
-      context 'when there are some keys to clean' do 
-        it 'removes specified keys' do 
-          expect({:foo => 'bar', :baz => 'qux'}.clean(:baz)).to eql({:foo => 'bar'})
-        end
-
-        it 'doesn\'t change the original hash' do 
-          hash = {:foo => 'bar', :baz => 'qux', 'norf' => 'raboof'}
-          expect{ hash.clean(:baz, 'norf') }.not_to change(hash, :keys)
-        end
-      end
-
-      context 'when all keys must be cleaned' do 
-        it 'returns an empty hash' do 
-          expect({:foo => 'bar'}.clean(:foo)).to eql({})
-        end
-
-        it 'doesn\'t change the original hash' do 
-          hash = {:foo => 'bar'}
-          expect{ hash.clean(:foo) }.not_to change(hash, :keys)
-        end
-      end
-    end
-
-    describe 'clean!' do 
-      context 'when no cleaning is needed' do 
-        it 'returns the original hash' do 
-          expect({:foo => 'bar'}.clean!(:baz)). to eql({:foo => 'bar'})
-        end
-
-        it 'doesn\'t raise an error' do 
-          expect{ {:foo => 'bar'}.clean(:baz) }.not_to raise_error
-        end
-      end
-
-      context 'when there are some keys to clean' do 
-        it 'removes specified keys' do 
-          expect({:foo => 'bar', :baz => 'qux'}.clean!(:baz)).to eql({:foo => 'bar'})
-        end
-
-        it 'changes the original hash' do 
-          hash = {:foo => 'bar', :baz => 'qux', 'norf' => 'raboof'}
-          expect{ hash.clean!(:baz, 'norf') }.to change(hash, :keys)
-        end
-
-        it 'returns the hash' do 
-          hash = {:foo => 'bar', :baz => 'qux'}
-          expect(hash.clean!(:baz)).to eql hash
-        end
-      end
-
-      context 'when all keys must be cleaned' do 
-        it 'returns an empty hash' do 
-          expect({:foo => 'bar'}.clean!(:foo)).to eql({})
-        end
-
-        it 'changes the original hash' do 
-          hash = {:foo => 'bar'}
-          expect{ hash.clean!(:foo) }.to change(hash, :keys)
-        end
-
-        it 'returns the hash' do 
-          hash = {:foo => 'bar'}
-          expect(hash.clean!(:foo)).to eql hash
-        end
-      end
-    end
-  end
-
-  describe 'proc methods' do 
-    describe 'raises_error?' do
-      let(:proc) { Proc.new {|quotient| 1.quo(quotient) } }
-
-      context 'when an error is raised' do 
-        it 'returns true' do 
-          expect(proc.raises_error?(0)).to be true
-        end
-
-        it 'handles the exception' do 
-          expect{ proc.raises_error?(0) }.not_to raise_error
-        end
-      end
-
-      context 'when no error is raised' do 
-        it 'returns false' do 
-          expect(proc.raises_error?(2)).to be false
-        end
-
-        it 'doesn\'t change objects' do 
-          h, p = {:foo => :bar}, Proc.new {|hash| hash.reject! {|k,v| k === :foo } }
-          expect{ p.raises_error?(h) }.not_to change(h, :length)
-        end
-      end
-    end
-  end
-end