reactive_extensions 0.4.0.beta2 → 0.5.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a11a55078afe921816c40afd0f23d18393aaa427
-  data.tar.gz: aad0e58be3dfce1485fa97d16b866bd6b824590a
+  metadata.gz: f7bca1cd49086c183e79ac85eaf3a58a6adc0108
+  data.tar.gz: 515ab851d82683790e91dd98ca40d6ad485f6030
 SHA512:
-  metadata.gz: 5c8995508e2190fe170db68c6237861e84cfa802dc3ce90a05298f7022e054a6c31082b04e99f20f442248b14f6aa6e3ad272ce6e07f9929b2d3ecd2e9c55db0
-  data.tar.gz: 798588d3e82ff3aebdec060b5feefe452271d55e7ada29be6ced89357673f3669d04f9dae459b2e3828f90df89c64cb584609679eaaa9f6ce32cf0e42a3a3bdb
+  metadata.gz: 1f11b8b5d55f1e4fa906377f1a5a971478a065030d41833078b67b14483bf697668904a2030ef4cc0ed1f54be9fb09a30011088021923c45197cdeb48d052932
+  data.tar.gz: 4c35089ef2785298090e0cbd6991163eaf9ca80e4264e8f6a15c80e9019cec0a7154715dea75784500e449f04f5d3bdb9bd50be11e1d84f7bb5999c0283c1411

data/README.md

@@ -6,14 +6,14 @@ in the spirit of [ActiveSupport](https://github.com/rails/activesupport). This g
 be used in any kind of project and is not dependent on any frameworks, gemsets, etc.
 Its only runtime dependency is [ReactiveSupport](https://github.com/danascheider/reactive_support).
 To add ReactiveExtensions to your project, add this to your Gemfile and run `bundle install`:
-<pre><code>gem 'reactive_extensions', '~> 0.4.0.beta'</code></pre>
+<pre><code>gem 'reactive_extensions', '~> 0.5.0.beta'</code></pre>
 To install locally:
 <pre><code>sudo gem install reactive_extensions</code></pre>
 Or if you're using RVM: 
 <pre><code>gem install reactive_extensions</code></pre>
 
 You can also point your Gemfile to this repo:
-<pre><code>gem 'reactive_extensions', '~> 0.4.0.beta', git: 'https://github.com/danascheider/reactive_extensions.git</code></pre>
+<pre><code>gem 'reactive_extensions', '~> 0.5.0.beta', git: 'https://github.com/danascheider/reactive_extensions.git</code></pre>
 
 After installing, simply include this in your main project file:
 <pre><code>require 'reactive_support'</code></pre>

data/lib/reactive_extensions/sanitation.rb

@@ -0,0 +1,170 @@
+# This file adds the +#clean+, +#clean!+, +#only+, +#only!+, +#standardize+,
+# and +#standardize!+ methods to Ruby's core Hash class. These methods enable
+# the user to easily add or remove particular keys from a hash.
+
+# Ruby's core Has 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 +#clean+ method returns a duplicate of the calling hash with the 
+  # specified +*bad_keys+, if present, removed. If none of the bad keys
+  # are present, +#clean+ will simply return a duplicate hash. 
+  #
+  # +#clean+ is a non-destructive method. The original hash will still be
+  # unchanged after it is called.
+  #
+  # +#clean+ may also be called by the aliases +#not+ and +#except+.
+  #
+  # Examples:
+  #     hash = {:foo => 'bar', :bar => 'baz'}
+  #     hash.clean(:foo)                        # => {:bar => 'baz'}
+  #     hash.not(:foo, :bar)                    # => {}
+  #     hash.except(:bar, :norf)                # => {:foo => 'bar'}
+  #     hash.clean(:norf)                       # => {:foo => 'bar', :bar => 'baz'}
+  #     hash                                    # => {:foo => bar', :bar => 'baz'}
+
+  def clean(*bad_keys)
+    dup = self.reject {|key, value| bad_keys.flatten.include?(key) }
+    dup
+  end
+
+  alias_method :not, :clean
+  alias_method :except, :clean
+
+  # The +#clean!+ method returns a duplicate of the calling hash with the 
+  # specified +*bad_keys+, if present, removed. If none of the bad keys
+  # are present, +#clean!+ will simply return a duplicate hash. 
+  #
+  # +#clean!+ is a non-destructive method. The original hash will still be
+  # unchanged after it is called.
+  #
+  # +#clean!+ may also be called by the aliases +#not!+ and +#except!+.
+  #
+  # Examples:
+  #     hash = {:foo => 'bar', :bar => 'baz'}
+  #     hash.clean!(:foo)                       # => {:bar => 'baz'}
+  #     hash                                    # => {:bar => 'baz'}
+  # 
+  #     hash.not!(:foo, :bar)                   # => {}
+  #     hash                                    # => {}
+  # 
+  #     hash = {:foo => 'bar', :bar => 'baz'}
+  #     hash.except!(:bar, :norf)               # => {:foo => 'bar'}
+  #     hash                                    # => {:foo => 'bar'}
+
+  def clean!(*bad_keys)
+    reject! {|key, value| bad_keys.flatten.include?(key) }
+    self
+  end
+
+  alias_method :not!, :clean!
+  alias_method :except!, :clean!
+
+  # The +#only+ method returns a duplicate of the calling hash with only the 
+  # specified +*good_keys+, if present. If none of the good keys
+  # are present, +#only+ will simply return an empty hash. 
+  #
+  # +#only+ is a non-destructive method. The original hash will still be
+  # unchanged after it is called.
+  #
+  # Examples:
+  #     hash = {:foo => 'bar', :bar => 'baz'}
+  #     hash.only(:foo)                         # => {:foo => 'bar'}
+  #     hash.only(:qux)                         # => {}
+  #     hash                                    # => {:foo => 'bar', :bar => 'baz'}
+
+  def only(*good_keys)
+    dup = self.select {|key, value| good_keys.flatten.include?(key) }
+  end
+
+  # The +#only!+ method returns a duplicate of the calling hash with only the 
+  # specified +*good_keys+, if present. If none of the good keys
+  # are present, +#only!+ will simply return an empty hash. 
+  #
+  # +#only!+ is a destructive method. The original hash will be changed in place
+  # when it is called.
+  #
+  # Examples:
+  #     hash = {:foo => 'bar', :bar => 'baz'}
+  #     hash.only!(:foo)                         # => {:foo => 'bar'}
+  #     hash.only!(:qux)                         # => {}
+  #     hash                                     # => {}
+
+  def only!(*good_keys)
+    select! {|key, value| good_keys.flatten.include?(key) }
+    self
+  end
+
+  # The +#standardize+ method returns a duplicate of the calling hash with
+  # the +*keys+ specified as arguments. Any other keys in the hash will be 
+  # removed. Behavior when adding keys depends on whether the +:errors+
+  # option is set to +true+ or +false+ (default). 
+  #
+  # If the +:errors+ option is set to +false+, the method will add any missing
+  # keys to the hash, populating them with +nil+ values. If +:errors+ is set to 
+  # +true+, then an +ArgumentError+ will be raised unless all values are 
+  # present in the hash already.
+  #
+  # Examples with +:errors => false+:
+  #     hash = {:foo => 'bar', :bar => 'baz'}
+  #     hash.standardize(:foo)                  # => {:foo => 'bar'}
+  #     hash.standardize(:foo, :qux)            # => {:foo => 'bar', :qux => nil}
+  #     hash                                    # => {:foo => 'bar', :bar => 'baz'}
+  #
+  # Examples with +:errors => true+:
+  #     hash = {:foo => 'bar', :bar 'baz'}
+  #     hash.standardize(:foo, :errors => true)           # => {:foo => 'bar'}
+  #     hash.standardize(:foo, :qux, :errors => true)     # => ArgumentError
+
+  def standardize(*kees)
+    options = kees.extract_options!
+    dup     = deep_dup.only(kees)
+
+    kees.each do |key| 
+      unless dup.has_key? key
+        raise ArgumentError.new("#{self} is missing required key #{key}") if options[:errors]
+        dup[key] = nil
+      end
+    end
+
+    dup
+  end
+
+  # The +#standardize!+ method modifies the calling hash such that its 
+  # keys match the +*kees+ specified as arguments. Any other keys in the hash 
+  # will be removed. If passed +:errors => true+, an +ArgumentError+ will be
+  # raised in the event keys present in the arguments are not present in the
+  # calling hash. Otherwise, any such keys will be added to the hash and 
+  # populated with nil values.
+  #
+  # +#standardize!+ is a destructive method; the calling hash will be changed
+  # in place when it is called.
+  #
+  # Examples with +:errors => false+:
+  #     hash = {:foo => 'bar', :bar => 'baz'}
+  #     hash.standardize!(:foo, :qux)            # => {:foo => 'bar', :qux => nil}
+  #     hash.standardize!(:foo)                  # => {:foo => 'bar'}
+  #     hash                                     # => {:foo => 'bar'}
+  #
+  # Examples with +:errors => true+:
+  #     hash = {:foo => 'bar', :bar 'baz'}
+  #     hash.standardize!(:foo, :errors => true)           # => {:foo => 'bar'}
+  #     hash.standardize!(:foo, :qux, :errors => true)     # => ArgumentError
+  #     hash                                               # => {:foo => 'bar'}
+
+  def standardize!(*kees)
+    options = kees.extract_options!
+
+    kees.each do |key|
+      unless only!(kees).has_key? key
+        raise ArgumentError.new("#{self} is missing required key #{key}") if options[:errors]
+        self[key] = nil
+      end
+    end
+
+    self
+  end
+end

data/lib/reactive_extensions/sets.rb

@@ -0,0 +1,80 @@
+class Hash
+  
+  # The +#subset_of?+ method checks whether the calling hash is a subset
+  # of the given +hash+. It returns true if all key-value pairs in
+  # the calling hash are also present in the hash passed as an argument.
+  # If the calling hash is empty, the method returns true.
+  #
+  # Examples:
+  #     hash = {:foo => 'bar', :bar => 'baz', :baz => 'qux'}
+  #     {:baz => 'qux'}.subset_of? hash                          # => true
+  #     {:bar => 'baz', :norf => 'foo'}.subset_of? hash          # => false
+  #     {:norf => 'foo'}.subset_of? hash                         # => false
+  #     {:foo => 'qux'}.subset_of? hash                          # => false
+  #     {}.subset_of? hash                                       # => true
+  #     {:foo => 'bar'}.subset_of? 'foobar'                      # => ArgumentError
+
+  def subset_of?(hash)
+    raise ArgumentError.new("Argument of #subset_of? must share the class of the calling object") unless hash.instance_of? Hash
+    each {|key, value| return false unless hash[key] === value }
+    true
+  end
+
+  # The +#superset_of?+ method checks whether the calling hash is a superset
+  # of the given +hash+. It returns true if all key-value pairs in
+  # the calling hash are also present in the hash passed as an argument.
+  # If the argument hash is empty, the method returns true.
+  #
+  # Examples:
+  #     hash = {:foo => 'bar', :bar => 'baz', :baz => 'qux'}
+  #     hash.superset_of? {:baz => 'qux'}                          # => true
+  #     hash.superset_of? {:bar => 'baz', :norf => 'foo'}          # => false
+  #     hash.superset_of? {:norf => 'foo'}                         # => false
+  #     hash.superset_of? {:foo => 'qux'}                          # => false
+  #     hash.superset_of? {}                                       # => true
+  #     {:foo => 'bar'}.superset_of? 'foobar'                      # => ArgumentError
+
+  def superset_of?(hash)
+    raise ArgumentError.new("Argument of Hash#superset_of? must be a hash") unless hash.instance_of? Hash
+    hash.subset_of? self
+  end
+end
+
+class Array
+
+  # The +#subset_of?+ method checks whether the calling array is a subset
+  # of the given +array+. It returns true if all objects in the calling 
+  # array are also present in the hash passed as an argument, regardless 
+  # of order. If the calling array is empty, the method returns true.
+  #
+  # Examples:
+  #     array = [1, 2, 3, 4]
+  #     [1, 3].subset_of? array                   # => true
+  #     [1, 6].subset_of? array                   # => false
+  #     [].subset_of? array                       # => true
+  #     array.subset_of? 'foobar'                 # => ArgumentError
+
+  def subset_of?(array)
+    raise ArgumentError.new("Argument of Array#subset_of? must be an array") unless array.instance_of? Array
+    each {|i| return false unless array.include? i }
+    true
+  end
+
+  # The +#superset_of?+ method checks whether the calling array is a superset
+  # of the given +array+. It returns true if all objects in the calling array
+  # are also present in the array passed as an argument. If the argument array 
+  # is empty, the method returns true.
+  #
+  # Examples:
+  #     array = [1, 2, 3, 4]
+  #     array.superset_of? [1, 2]                          # => true
+  #     array.superset_of? [1, 2, 3, 4]                    # => true
+  #     array.superset_of? [3, 6]                          # => false
+  #     array.superset_of? []                              # => true
+  #     array.superset_of? {}                              # => ArgumentError
+
+  def superset_of?(array)
+    raise ArgumentError.new("Argument of Array#superset_of? must be an array") unless array.instance_of? Array
+    array.subset_of? self
+  end
+end

data/lib/reactive_extensions/subtraction.rb

@@ -0,0 +1,18 @@
+class Hash
+
+  # The +#-+ method takes a single hash as an argument. It 
+  # deletes the key-value pairs of the argument from the calling
+  # hash. An ArgumentError is raised if the argument is not a 
+  # hash or not a subset of the 
+  #
+  # Examples:
+  #     {:foo => 'bar', :baz => :qux} - {:baz => :qux}   # => {:foo => 'bar'}
+  #     {:foo => 'bar'} - {:norf => :raboo}              # => {:foo => 'bar'}
+  #     {:foo => 'bar'} - {:foo => 'bar'}
+  #     {:foo => 'bar'} - [1, 2, 3]                      # => ArgumentError
+
+  def - (hash)
+    raise ArgumentError.new("Hash can only be subtracted from its superset") unless superset_of? hash
+    deep_dup.reject {|key, value| hash.has_key? key }
+  end
+end

data/lib/reactive_extensions/try_rescue.rb

@@ -35,22 +35,28 @@ class Object
   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
+# Ruby's core NilClass. See documentation for version 
+# 2.1.5[http://ruby-doc.org/core-2.1.5/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
+
+  # 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
+
   def try_rescue(*args, &block)
     nil 
   end

data/lib/reactive_extensions.rb

@@ -2,6 +2,7 @@ require 'reactive_support/core_ext/object/duplicable'
 require 'reactive_support/core_ext/object/deep_dup'
 require 'reactive_support/core_ext/object/inclusion'
 require 'reactive_support/core_ext/object/try'
+require 'reactive_support/core_ext/array/extract_options'
 
 Dir['./lib/reactive_extensions/**/*.rb'].each {|f| require f }
 

data/reactive_extensions.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
 
   s.name                      = 'reactive_extensions'
   s.version                   = ReactiveExtensions.gem_version
-  s.date                      = '2014-11-29'
+  s.date                      = '2014-11-30'
 
   s.description               = 'Handy extensions to core Ruby classes'
   s.summary                   = 'ReactiveExtensions, a spinoff of ReactiveSupport, adds a variety of useful methods to core Ruby classes.'

data/spec/array_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'reactive_support/core_ext/hash/keys'
+require 'reactive_support/core_ext/array/extract_options'
 
 describe Array do 
   describe 'array scoping' do 
@@ -9,7 +10,7 @@ describe Array do
     let(:camus) { { 'name' => 'Albert Camus', 'nationality' => 'French' } }
     let(:array) { [sartre, russell, wittgenstein, camus] }
 
-    describe 'array #scope method' do 
+    describe 'scope' do 
       context 'symbol keys' do
         context 'single value' do 
           it 'returns scoped hashes' do 
@@ -41,7 +42,7 @@ describe Array do
       end
     end
 
-    describe 'array #where_not method' do 
+    describe 'where_not' do 
       context 'symbol keys' do 
         context 'single value' do 
           it 'returns scoped hashes' do 
@@ -73,4 +74,82 @@ describe Array do
       end
     end
   end
+
+  describe 'sets' do 
+    describe 'subset_of?' do 
+      context 'when the argument is a strict superset of the subject' do 
+        it 'returns true' do 
+          expect([1, 2].subset_of? [1, 2, 3, 4]).to be true
+        end
+      end
+
+      context 'when the argument is equal to the subject' do 
+        it 'returns true' do 
+          expect([1, 2].subset_of? [1, 2]).to be true
+        end
+      end
+
+      context 'when the calling array is empty' do 
+        it 'returns true' do 
+          expect([].subset_of?(['foo', 'bar', 'baz'])).to be true 
+        end
+      end
+
+      context 'when the elements are not consecutive' do 
+        it 'returns true' do 
+          expect([2, 4].subset_of? [1, 2, 3, 4]).to be true
+        end
+      end
+
+      context 'when the calling object is inside the argument' do 
+        it 'returns false' do 
+          expect([1, 2].subset_of? [[1, 2], 3, 4]).to be false
+        end
+      end
+
+      context 'when the argument is not an array' do 
+        it 'raises an error' do 
+          expect{[1, 2].subset_of? {}}.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    describe 'superset_of?' do 
+      context 'when the argument is a strict subset of the subject' do 
+        it 'returns true' do 
+          expect([1, 2, 3, 4].superset_of? [1, 2]).to be true
+        end
+      end
+
+      context 'when the argument is equal to the subject' do 
+        it 'returns true' do 
+          expect([1, 2].superset_of? [1, 2]).to be true
+        end
+      end
+
+      context 'when the argument array is empty' do 
+        it 'returns true' do 
+          expect(['foo', 'bar', 'baz'].superset_of?([])).to be true 
+        end
+      end
+
+      context 'when the elements are not consecutive' do 
+        it 'returns true' do 
+          expect([1, 2, 3, 4].superset_of? [1, 4]).to be true
+        end
+      end
+
+      context 'when the argument is a single index' do 
+        it 'returns false' do 
+          expect([[1, 2], 3, 4].superset_of? [1, 2]).to be false
+        end
+      end
+
+      context 'when the argument is not an array' do 
+        it 'raises an error' do 
+          expect{[1, 2].superset_of? 427}.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
 end

data/spec/hash_spec.rb

@@ -0,0 +1,321 @@
+require 'spec_helper' 
+
+describe Hash do 
+  let(:hash) { { :foo => 'bar', :baz => 'qux' } }
+
+  describe '-' do 
+    context 'when the argument is a subset of the calling hash' do 
+      it 'removes the keys of the argument from the calling hash' do 
+        expect(hash - {:baz => 'qux'}).to eql({:foo => 'bar'})
+      end
+    end
+
+    context 'when the argument has additional keys' do 
+      it 'raises an argument error' do 
+        expect{ hash - {:baz => 'qux', :norf => 'raboof'} }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'shared keys with unshared values' do 
+      it 'raises an error' do 
+        expect{ hash - {:foo => 'baz'} }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when the argument is not a hash' do 
+      it 'raises an ArgumentError' do 
+        expect{ hash - 'foobar' }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe 'clean' do 
+    it 'removes specified keys' do 
+      expect(hash.clean(:baz)).to eql({:foo => 'bar'})
+    end
+
+    it 'is non-destructive' do 
+      expect{ hash.clean(:baz) }.not_to change(hash, :length)
+    end
+
+    it 'ignores absent keys' do 
+      expect{ hash.clean(:raboof) }.not_to raise_error
+    end
+
+    it 'accepts multiple arguments' do 
+      expect(hash.clean(:baz, :raboof, :norf)).to eql({:foo => 'bar'})
+    end
+
+    context 'when all keys are bad' do 
+      it 'returns an empty hash' do 
+        expect(hash.clean(:foo, :baz)).to eql({})
+      end
+    end
+  end
+
+  describe 'clean!' do 
+    it 'removes specified keys' do 
+      expect(hash.clean!(:baz)).to eql({:foo => 'bar'})
+    end
+
+    it 'is destructive' do 
+      expect{ hash.clean!(:baz) }.to change(hash, :length)
+    end
+
+    it 'ignores absent keys' do 
+      expect{ hash.clean!(:raboof) }.not_to raise_error
+    end
+
+    it 'accepts multiple arguments' do 
+      expect(hash.clean!(:baz, :raboof, :norf)).to eql({:foo => 'bar'})
+    end
+
+    context 'when all keys are bad' do 
+      it 'returns an empty hash' do 
+        expect(hash.clean!(:foo, :baz)).to eql({})
+      end
+    end
+  end
+
+  describe 'only' do 
+    it 'retains only listed keys' do 
+      expect(hash.only(:foo)).to eql({:foo => 'bar'})
+    end
+
+    it 'is non-destructive' do 
+      expect{ hash.only(:foo) }.not_to change(hash, :length)
+    end
+
+    it 'accepts multiple arguments' do 
+      expect(hash.only(:foo, :baz)).to eql({:foo => 'bar', :baz => 'qux'})
+    end
+
+    context 'when no keys are allowed' do 
+      it 'returns an empty hash' do 
+        expect(hash.only(:raboof)).to eql({})
+      end
+
+      it 'doesn\'t raise an error' do 
+        expect{ hash.only(:raboof) }.not_to raise_error
+      end
+    end
+  end
+
+  describe 'only!' do 
+    it 'retains only listed keys' do 
+      expect(hash.only!(:foo)).to eql({:foo => 'bar'})
+    end
+
+    it 'is destructive' do 
+      expect{ hash.only!(:foo) }.to change(hash, :keys)
+    end
+
+    it 'accepts multiple arguments' do 
+      expect(hash.only!(:foo, :baz, :norf)).to eql({:foo => 'bar', :baz => 'qux'})
+    end
+
+    context 'when no keys are allowed' do 
+      it 'empties the hash' do 
+        expect(hash.only!(:raboof)).to eql({})
+      end
+
+      it 'doesn\'t raise an error' do 
+        expect{ hash.only!(:raboof) }.not_to raise_error
+      end
+    end
+  end
+
+  describe 'standardize' do 
+    let(:hash) { { :foo => 'bar', :bar => 'baz', :baz => 'qux' } }
+
+    it 'is non-destructive' do 
+      expect{ hash.standardize(:foo, :bar) }.not_to change(hash, :keys)
+    end
+
+    context 'exact match' do 
+      it 'returns the hash as-is' do 
+        expect(hash.standardize(:foo, :bar, :baz)).to eql hash 
+      end
+    end
+
+    context 'keys removed' do 
+      it 'removes keys not given in args' do 
+        expect(hash.standardize(:foo, :baz)).to eql({:foo => 'bar', :baz => 'qux'})
+      end
+    end
+
+    context 'args include keys not present in hash' do 
+      let(:with_nil) { {:foo => 'bar', :bar => 'baz', :baz => 'qux', :norf => nil } }
+
+      context 'default' do 
+        it 'populates with nil values' do 
+          expect(hash.standardize(:foo, :bar, :baz, :norf)).to eql(with_nil)
+        end
+
+        it 'doesn\'t raise an error' do 
+          expect{ hash.standardize(:foo, :bar, :baz, :norf) }.not_to raise_error
+        end
+      end
+
+      context 'with errors option set to false' do 
+        it 'populates with nil values' do 
+          expect(hash.standardize(:foo, :bar, :baz, :norf, :errors => false)).to eql(with_nil)
+        end
+
+        it 'doesn\'t raise an error' do 
+          expect{ hash.standardize(:foo, :bar, :baz, :norf, :errors => false) }.not_to raise_error
+        end
+      end
+
+      context 'with errors option set to true' do 
+        it 'raises an error' do 
+          expect{ hash.standardize(:foo, :bar, :baz, :norf, :errors => true) }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+
+  describe 'standardize!' do 
+    let(:hash) { { :foo => 'bar', :bar => 'baz', :baz => 'qux' } }
+
+    it 'is destructive' do 
+      expect{ hash.standardize!(:foo, :bar) }.to change(hash, :keys)
+    end
+
+    context 'exact match' do 
+      it 'returns the hash as-is' do 
+        expect(hash.standardize!(:foo, :bar, :baz)).to eql hash 
+      end
+    end
+
+    context 'keys removed' do 
+      it 'removes keys not given in args' do 
+        expect(hash.standardize!(:foo, :baz)).to eql({:foo => 'bar', :baz => 'qux'})
+      end
+    end
+
+    context 'args include keys not present in hash' do 
+      let(:with_nil) { {:foo => 'bar', :bar => 'baz', :baz => 'qux', :norf => nil } }
+
+      context 'default' do 
+        it 'populates with nil values' do 
+          expect(hash.standardize!(:foo, :bar, :baz, :norf)).to eql(with_nil)
+        end
+
+        it 'doesn\'t raise an error' do 
+          expect{ hash.standardize!(:foo, :bar, :baz, :norf) }.not_to raise_error
+        end
+      end
+
+      context 'with errors option set to false' do 
+        it 'populates with nil values' do 
+          expect(hash.standardize!(:foo, :bar, :baz, :norf, :errors => false)).to eql(with_nil)
+        end
+
+        it 'doesn\'t raise an error' do 
+          expect{ hash.standardize!(:foo, :bar, :baz, :norf, :errors => false) }.not_to raise_error
+        end
+      end
+
+      context 'wtih errors option set to true' do 
+        it 'raises an error' do 
+          expect{ hash.standardize!(:foo, :bar, :baz, :norf, :errors => true) }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+
+  describe 'subset_of?' do 
+    let(:hash)   { {:foo => 'bar', :bar => 'baz', :baz => 'qux'} }
+
+    context 'when true' do 
+      it 'returns true' do 
+        expect({:bar => 'baz'}.subset_of?(hash)).to be true
+      end
+    end
+
+    context 'when the calling hash is empty' do 
+      it 'returns true' do 
+        expect({}.subset_of?(hash)).to be true
+      end
+    end
+
+    context 'when not all keys are shared' do 
+      it 'returns false' do 
+        expect({:bar => 'baz', :norf => 'qux'}.subset_of?(hash)).to be false
+      end
+    end
+
+    context 'when keys are shared but not values' do 
+      it 'returns false' do 
+        expect({:bar => 'foo'}.subset_of?(hash)).to be false
+      end
+    end
+
+    context 'when there are no shared keys' do 
+      it 'returns false' do 
+        expect({:norf => 'baz'}.subset_of?(hash)).to be false
+      end
+    end
+
+    context 'when the hash constitutes a value in a larger hash' do 
+      it 'returns false' do 
+        expect(hash.subset_of?({:norf => hash})).to be false
+      end
+    end
+
+    context 'when argument is not a hash' do 
+      it 'raises an error' do 
+        expect{ hash.subset_of?('foobar') }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when the calling hash is '
+  end
+
+  describe 'superset_of?' do 
+    let(:hash)   { {:foo => 'bar', :bar => 'baz', :baz => 'qux'} }
+
+    context 'when true' do 
+      it 'returns true' do 
+        expect(hash.superset_of?({:bar => 'baz'})).to be true
+      end
+    end
+
+    context 'when the argument hash is empty' do 
+      it 'returns true' do 
+        expect(hash.superset_of?({})).to be true
+      end
+    end
+
+    context 'when not all keys are shared' do 
+      it 'returns false' do 
+        expect(hash.superset_of?({:bar => 'baz', :norf => 'qux'})).to be false
+      end
+    end
+
+    context 'when keys are shared but not values' do 
+      it 'returns false' do 
+        expect(hash.superset_of?({:bar => 'foo'})).to be false
+      end
+    end
+
+    context 'when there are no shared keys' do 
+      it 'returns false' do 
+        expect(hash.superset_of?({:norf => 'baz'})).to be false
+      end
+    end
+
+    context 'when the hash constitutes a value in a larger hash' do 
+      it 'returns false' do 
+        expect({:norf => hash}.superset_of?(hash)).to be false
+      end
+    end
+
+    context 'when argument is not a hash' do 
+      it 'raises an error' do 
+        expect{ hash.superset_of?('foobar') }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reactive_extensions
 version: !ruby/object:Gem::Version
-  version: 0.4.0.beta2
+  version: 0.5.0.beta
 platform: ruby
 authors:
 - Dana Scheider
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-29 00:00:00.000000000 Z
+date: 2014-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: reactive_support
@@ -116,9 +116,13 @@ extra_rdoc_files:
 files:
 - "./lib/reactive_extensions.rb"
 - "./lib/reactive_extensions/errors.rb"
+- "./lib/reactive_extensions/sanitation.rb"
 - "./lib/reactive_extensions/scope.rb"
+- "./lib/reactive_extensions/sets.rb"
+- "./lib/reactive_extensions/subtraction.rb"
 - "./lib/reactive_extensions/try_rescue.rb"
 - "./spec/array_spec.rb"
+- "./spec/hash_spec.rb"
 - "./spec/object_spec.rb"
 - "./spec/proc_spec.rb"
 - "./spec/spec_helper.rb"