reactive_support 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 98b652c949f27c7bddcd372807affcdd75d17493
-  data.tar.gz: ea175e6c84e532cb9e7a0efd837b6160ea5b8f15
+  metadata.gz: 12316fe1f1d8b76b86dfe2eccf71ed8a88e75cd3
+  data.tar.gz: 14b7c50140d8b81e921efaba7505cb3b8e6cee17
 SHA512:
-  metadata.gz: 7bc1f3cc4511bf351b9bbe414cc29b82789fde75770f786e7f046960d384be222629d0fa9caaf5e24afb23f735fbd71fd14def11274af80de6ee7671fca9f93f
-  data.tar.gz: 60019de6cab75f7c638938e2b030a49bc3136fe193f34369f4fbf60a6fbf2c5329c5307659cbcd9892d02b30393f0e1d76a4054b37b35d5ac1f316765e15b221
+  metadata.gz: b6c2208404d0eec5f24732fc965833f62181cc41bfd8853d3c21a6d6b91b65e508ce120f77aa7c90562090d2ac3dff29388a78bd3427521766b042c5e3004e9b
+  data.tar.gz: 2d3057e90220183049bda134a4fd412628649697e442a8e1ea8fa03ea45d222373176d4d70fe3568eb9d265a434f5acbd7926927c3be7eb1a09d4e784938c50c

data/lib/extensions/array_extensions.rb

@@ -1,7 +1,7 @@
 class Array
   
   # The +#scope+ method is called on an array of hashes. It returns a sub-array
-  # including only hashes for which the given +key+ equals the given +value+.
+  # including only hashes for which the value at a given +key+ equals the given +value+.
   # 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.
@@ -20,7 +20,32 @@ class Array
   #              { name: 'Albert Camus', nationality: 'French' }
   #            ]
 
-  def scope(key, value)
-    self.reject {|hash| hash[key] != value }
+  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+ does not equal the
+  # given value. 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/extensions/hash_extensions.rb

@@ -0,0 +1,88 @@
+class Hash
+
+  # 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/spec/reactive_extensions_spec.rb

@@ -21,28 +21,120 @@ describe ReactiveExtensions do
     end
   end
 
-  describe 'array #scope method' do 
-    context 'symbol keys' 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 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] }
 
-      it 'returns scoped hashes' do 
-        expect(array.scope(:nationality, 'French')).to eql([sartre, 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
 
-    context 'string keys' 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 '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 'returns scoped hashes' do 
-        expect(array.scope('nationality', 'French')).to eql([sartre, camus])
+      it 'overwrites the original hash' do
+        hash = { foo: 'bar' }
+        expect { hash.stringify_keys! }.to change(hash, :keys)
       end
     end
   end

data/version.rb

@@ -5,8 +5,8 @@ module ReactiveSupport
 
   module Version
     MAJOR = '0'
-    MINOR = '1'
-    PATCH = '3'
+    MINOR = '2'
+    PATCH = '0'
     PRE   = ''
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.').chomp('.')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reactive_support
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Dana Scheider
@@ -76,6 +76,7 @@ extra_rdoc_files:
 - LICENSE
 files:
 - "./lib/extensions/array_extensions.rb"
+- "./lib/extensions/hash_extensions.rb"
 - "./lib/extensions/reactive_extensions.rb"
 - "./lib/reactive_support.rb"
 - "./lib/reactive_support/core_ext/array/access.rb"