reactive_support 0.3.0.beta → 0.3.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e03c0b062f28792315df4ddeb261e6084d93495
-  data.tar.gz: 022f699675dcb56d66c9f1fd5f1c65b900d1edd2
+  metadata.gz: a54091a52002588f7f971f0d2327ff2d5f521675
+  data.tar.gz: 3fa7f6ba5efdaa4b4565d25013ff5e43179f6ae0
 SHA512:
-  metadata.gz: 00f6717977c36891e7df8f75f3935e9d9c0baf91618dea25415e6f8adf486168fc7ab678527b9cc6137df02358ff919bfbd40167bd2c595a00535611f7174e50
-  data.tar.gz: e0db1dcf183d452823e6bffb71ab33322f92c42f21882fb3ebd90c3ba9e115d51651ae7d7eb4ebd38deaa9a7447957b2ad5008d4f0f03ada7940302b8b9335ef
+  metadata.gz: 1f693c85385f91a5bcd4d5d5eb652b7695c5cdf816c6fbc91c02ed7c05a307e429849e05002d7cdad510fd6d7e87a3e56a8693eeda141ee034342632562cccc0
+  data.tar.gz: a3b687c0248b3f58245ec69ae532d4a4ed0d16e382583336e833228ea0f151b1da9f5d8c6f66da2615be8084800286f5c592bf8e6260db43e4c4b42313458118

data/lib/reactive_support/extensions/hash_extensions.rb

@@ -1,5 +1,52 @@
 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.

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-25'
+  s.date                      = '2014-11-27'
 
   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."

data/spec/reactive_extensions_spec.rb

@@ -137,6 +137,84 @@ describe ReactiveExtensions do
         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 

data/version.rb

@@ -7,7 +7,7 @@ module ReactiveSupport
     MAJOR = '0'
     MINOR = '3'
     PATCH = '0'
-    PRE   = 'beta'
+    PRE   = 'beta2'
 
     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.3.0.beta
+  version: 0.3.0.beta2
 platform: ruby
 authors:
 - Dana Scheider
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-25 00:00:00.000000000 Z
+date: 2014-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -123,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 1
 summary: ReactiveSupport provides useful ActiveSupport methods in a gem that is simple,