depth 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4571967f84027109674890d8d99993df6515740d
-  data.tar.gz: 031c3763b9bf00568b76d70b6ef59f5bfcccfe4d
+  metadata.gz: 0e40cab4a65c17f79c8dd51b99c7a5abd34c254a
+  data.tar.gz: 7e39b1a02e7ccbe5e2c40a89b489b30b5bc3bc8a
 SHA512:
-  metadata.gz: 18b2fc8ca9c8b8145366ad48e1e7df6c9c36696c7ab2de5eb3728641d5f778eb5eb70f8dbeccf79003e8fd166e964c983449c24e1a0193930d6f8cb53c3af535
-  data.tar.gz: 2c9e9dd29645a4a35bcc4531bf46392318586a47502d631e01a849f0c598ad32612e939bf41255a65aac545eaa69e76d9b868b86ee352e7972cb242739217f6d
+  metadata.gz: dd73d5e07c490e333b57e2206b01619c341d9702a0dd9139d9d911a7bc306bf43062a60e0e85310adf025ecf5fc939cda514e1051dc069a5545af1a235baf395
+  data.tar.gz: f090c3154f0fb9c2846ee0e7ffb1333be42a2902cf65bcca4e9e2d6fda61d870ed08c4c9d94bd0d856d24ea66f58a6b1cfeba621262c4c5835a774fdf5ff2773

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/README.md

@@ -1,3 +1,242 @@
 # Depth
 
+Depth is a utility gem for deep manipulation of complex hashes, that
+is nested hash and array structures. As you have probably guessed it
+was originally created to deal with a JSON like document structure.
+Importantly it uses a non-recursive approach to its enumeration.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'depth'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install depth
+
+## Usage
+
+### The complex hash
+
+```ruby
+  hash = { '$and' => [
+    { '#weather' => { 'something' => [], 'thisguy' => 4 } },
+    { '$or' => [
+      { '#otherfeed' => {'thing' => [] } },
+    ]}
+  ]}
+```
+_Nicked from a query engine we're using on Driftrock_
+
+The above is a sample complex hash, to use the gem to
+start manipulating it is pretty simple:
+
+```ruby
+  complex_hash = Depth::ComplexHash.new(hash)
+```
+
+Not exactly rocket science (not even data science). You
+can retrieve the hash with either `base` or `to_h`.
+
+### Manipulation
+
+Manipulation of the hash is done using routes. A route
+being a description of how to traverse the hash to
+get to this point.
+
+The messages signatures relating to manipulation are:
+
+* `set(route, value)` = Set a value
+* `find(route)` = Find a value
+* `alter(route, key:)` = Alter a key (the last key in route)
+* `alter(route, value:)` = Alter a value, identical to `set`
+* `alter(route, key: value:)` = Alter a key and value, identical to a `set` and then `delete`
+* `delete(route)` = Delete a value
+
+Routes can be defined as an array of keys or indeces:
+
+```ruby
+  hash = { '$and' => [
+    { '#weather' => { 'something' => [], 'thisguy' => 4 } },
+    { '$or' => [
+      { '#otherfeed' => {'thing' => [] } },
+    ]}
+  ]}
+  route = ['$and', 1, '$or', 0, '#otherfeed', 'thing']
+  Depth::ComplexHash.new(hash).find(route) # => []
+```
+
+But there's something cool hidden in the `set` message,
+if part of the structure is missing, it'll fill it in as it
+goes, e.g.:
+
+```ruby
+  hash = { '$and' => [
+    { '#weather' => { 'something' => [], 'thisguy' => 4 } },
+    { '$or' => [
+      { '#otherfeed' => {'thing' => [] } },
+    ]}
+  ]}
+  route = ['$and', 1, '$or', 0, '#sup', 'thisthing']
+  Depth::ComplexHash.new(hash).set(route, 'hello')
+  puts hash.inspect #=>
+  # hash = { '$and' => [
+  #   { '#weather' => { 'something' => [], 'thisguy' => 4 } },
+  #   { '$or' => [
+  #     { '#otherfeed' => {'thing' => [] } },
+  #     { '#sup' => {'thisthing' => 'hello' } },
+  #   ]}
+  # ]}
+```
+
+Great if you want it to be a hash, but what if you want to add
+an array, no worries, just say so in the route:
+
+```ruby
+  route = ['$and', 1, '$or', 0, ['#sup', :array], 0]
+  # Routes can also be defined in other ways
+  route = ['$and', 1, '$or', 0, { key: '#sup', type: :array }, 0]
+  route = ['$and', 1, '$or', 0, RouteElement.new('#sup', type: :array), 0]
+```
+
+### Enumeration
+
+The messages signatures relating to enumeration are:
+
+* `each` = yields `key_or_index` and `fragment`, returns the complex hash
+* `map` = yields `key_or_index`, `fragment` and `parent_type`, returns a new complex hash
+* `map_values` = yields  `fragment`, returns a new complex hash
+* `map_keys` = yields `key_or_index`, returns a new complex hash
+* `map!`, `map_keys!` and `map_keys_and_values!`, returns a new complex hash
+* `reduce(memo)` = yields `memo`, `key` and `fragment`, returns memo
+* `each_with_object(obj)` = yields `key`, `fragment` and `object`, returns object
+
+_Fragment refers to a chunk of the original hash_
+
+These, perhaps, require a bit more explanation:
+
+#### each
+
+The staple, and arguably the most important, of all the enumeration methods,
+
+```ruby
+  hash = { ... }
+  Depth::ComplexHash.new(hash).each { |key, fragment| }
+```
+
+Each yields keys and associated fragments from the leaf nodes
+backwards. For example, the hash:
+
+```ruby
+  { '$and' => [{ 'something' => { 'x' => 4 } }] }
+```
+
+would yield:
+
+1. `x, 4`
+2. `something, { "x" => 4 }`
+3. `0, { "something" => {  "x" => 4 } }`
+4. `$and, [{ "something" => {  "x" => 4 } }]`
+
+
+#### map
+
+Map yields both the current key/index and the current fragment,
+expecting both returned in an array. I've yet to decide if
+there should be a third argument that tells you whether or not
+the key/index is for an array or a hash. I've not needed it
+but I suspect it might be useful. If it comes up I'll add it.
+
+
+```ruby
+  hash = { '$and' => [{ 'something' => { 'x' => 4 } }] }
+  Depth::ComplexHash.new(hash).map do |key, fragment|
+    [key, fragment]
+  end
+```
+
+like `each` the above would yield:
+
+1. `x, 4`
+2. `something, { "x" => 4 }`
+3. `0, { "something" => {  "x" => 4 } }`
+4. `$and, [{ "something" => {  "x" => 4 } }]`
+
+and with the contents being unchanged it would return a
+new complex hash with equal contents to the current one.
+
+#### map_values
+
+```ruby
+  hash = { '$and' => [{ 'something' => { 'x' => 4 } }] }
+  Depth::ComplexHash.new(hash).map_values do |fragment|
+    fragment
+  end
+```
+
+This will yield only the fragments from `map`, useful if
+you only wish to alter the value parts of the hash.
+
+#### map_keys
+
+```ruby
+  hash = { '$and' => [{ 'something' => { 'x' => 4 } }] }
+  Depth::ComplexHash.new(hash).map_keys do |key|
+    key
+  end
+```
+
+This will yield only the keys from `map`, useful if
+you only wish to alter the keys.
+
+#### map!, map_keys!, map_values!
+
+The same as their non-exclamation marked siblings save that
+they will cause the complex hash on which they operate to change.
+
+#### reduce and each_with_object
+
+Operate as you would expect. Can I take a moment to point out how
+irritating it is that `each_with_object` yields the object you pass
+in as its last argument while `reduce` yields it as its first O_o?
+
+```ruby
+  hash = { '$and' => [{ 'something' => { 'x' => 4 } }] }
+  Depth::ComplexHash.new(hash).reduce(0) do |memo, key, fragment|
+    memo += 1
+  end
+
+  Depth::ComplexHash.new(hash).each_with_object([]) do |key, fragment, obj|
+    obj << key
+  end
+```
+
+## Why?
+
+Alright, we needed to be able to find certain keys
+from all the keys contained within the complex hash as said keys
+were the instructions as to what data the hash would be able to match
+against. This peice of code was originally recursive. We were adding
+a feature that required us to also be able to edit these keys, mark
+them with a unique identifier. As I was writing this I decided I wasn't
+happy with the recursive nature of the key search as we have no guarantees
+about how nested the hash could be. As I refactored the find and built
+the edit it became obvious that the code wasn't tied to the project at
+hand so I refactored it out to here.
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/depth/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
 

data/lib/depth/actions.rb

@@ -1,8 +1,14 @@
 module Depth
   module Actions
+    #:nocov:
+    def base
+      raise NoMethodError.new('should be overridden')
+    end
+    #:nocov:
+
     def set(route, value)
       route = RouteElement.convert_route(route)
-      object = route[0 ... -1].reduce(Traverser.new(hsh)) { |t, route_el|
+      object = route[0 ... -1].reduce(Traverser.new(base)) { |t, route_el|
         t.next_or_create(route_el.key) { route_el.create }
       }.object
       object[route.last.key] = value
@@ -10,7 +16,7 @@ module Depth
 
     def find(route)
       route = RouteElement.convert_route(route)
-      route.reduce(Traverser.new(hsh)) { |t, route_el|
+      route.reduce(Traverser.new(base)) { |t, route_el|
         t.next(route_el.key)
       }.object
     end
@@ -19,16 +25,16 @@ module Depth
       return set(route, value) if key == nil
       route = RouteElement.convert_route(route)
       value = find(route) unless value
-      new_route = (route[0 ... -1] << RouteElement.convert(new_key))
+      new_route = (route[0 ... -1] << RouteElement.convert(key))
       set(new_route, value) # ensure it exists
       old_key = route.last.key
-      return unless old_key != new_key
+      return unless old_key != key
       delete(route)
     end
 
     def delete(route)
       route = RouteElement.convert_route(route)
-      traverser = route[0...-1].reduce(Traverser.new(hsh)) do |t, route_el|
+      traverser = route[0...-1].reduce(Traverser.new(base)) do |t, route_el|
         t.next(route_el.key)
       end
       if traverser.array?

data/lib/depth/complex_hash.rb

@@ -1,8 +1,9 @@
 module Depth
   class ComplexHash
     include Depth::Actions
-    include Depth::Enumerable
+    include Depth::Enumeration::Enumerable
     attr_reader :base
+    alias_method :to_h, :base
     def initialize(base = {})
       @base = base
     end

data/lib/depth/enumeration/enumerable.rb

@@ -1,82 +1,92 @@
 module Depth
-  module Enumerable
+  module Enumeration
+    module Enumerable
+      #:nocov:
+      def base
+        raise NoMethodError.new('should be overridden')
+      end
+      #:nocov:
 
-    def each_with_object(object, &block)
-      each do |key, fragment|
-        block.call(key, fragment, object)
+      def each_with_object(object, &block)
+        object.tap do |o|
+          each do |key, fragment|
+            block.call(key, fragment, o)
+          end
+        end
       end
-      object
-    end
 
-    def reduce(memo, &block)
-      each do |key, fragment|
-        memo = block.call(memo, key, fragment)
+      def reduce(memo, &block)
+        each do |key, fragment|
+          memo = block.call(memo, key, fragment)
+        end
+        memo
       end
-      memo
-    end
 
-    def map_keys!(&block)
-      @base = map_keys(&block).base
-    end
+      def map_keys!(&block)
+        @base = map_keys(&block).base
+        self
+      end
 
-    def map!(&block)
-      @base = map(&block).base
-    end
+      def map_values!(&block)
+        @base = map_values(&block).base
+        self
+      end
 
-    def map_keys_and_values!(&block)
-      @base = map_keys_and_values(&block).base
-    end
+      def map!(&block)
+        @base = map(&block).base
+        self
+      end
+
+      def map_keys(&block)
+        map do |key, fragment|
+          [block.call(key), fragment]
+        end
+      end
 
-    def map_keys(&block)
-      map_keys_and_values do |key, fragment|
-        [block.call(key), fragment]
+      def map_values(&block)
+        map do |key, fragment, parent_type|
+          [key, block.call(fragment)]
+        end
       end
-    end
 
-    # Convention is that only values are mapped
-    def map(&block)
-      map_keys_and_values do |key, fragment|
-        [key, block.call(fragment)]
+      def map(&block)
+        node_map do |node, new_q|
+          orig_key = node.parent_key
+          existing = new_q.find(node.route)
+          orig_fragment = existing.nil? ? node.fragment : existing
+          block.call(orig_key, orig_fragment)
+        end
       end
-    end
 
-    def map_keys_and_values(&block)
-      node_map do |node, new_q|
-        orig_key = node.parent_key
-        existing = new_q.find(node.route)
-        orig_fragment = existing.nil? ? node.fragment : existing
-        next [orig_key, orig_fragment] unless node.parent.hash?
-        block.call(orig_key, orig_fragment)
+      def each(&block)
+        enumerate { |node| block.call(node.parent_key, node.fragment) }
       end
-    end
 
-    def each(&block)
-      enumerate { |node| block.call(node.parent_key, node.fragment) }
-    end
+      private
 
-    private
+      def node_map(&block)
+        new_q = self.class.new(base.class.new)
+        enumerate do |node|
+          key, val = block.call(node, new_q)
+          new_q.alter(node.route, key: key, value: val)
+        end
+        new_q
+      end
 
-    def node_map(&block)
-      new_q = ComplexHash.new(base.class.new)
-      enumerate do |node|
-        key, val = block.call(node, new_q)
-        new_q.alter(node.route, key: key, value: val)
+      def enumerate
+        root = Node.new(nil, nil, base)
+        current = root
+        begin
+          if current.next?
+            current = current.next
+          elsif !current.root?
+            yield(current)
+            current = current.parent
+          end
+        end while !current.root? || current.next?
+        self
       end
-      new_q
-    end
 
-    def enumerate
-      root = Node.new(nil, nil, query)
-      current = root
-      begin
-        if current.next?
-          current = current.next
-        elsif !current.root?
-          yield(current)
-          current = current.parent
-        end
-      end while !current.root? || current.next?
-      root.fragment
     end
   end
 end

data/lib/depth/enumeration/node.rb

@@ -9,7 +9,7 @@ module Depth
         route = []
         current = self
         while(!current.root?)
-          route << RouteElement.new(current.parent_key, fragment_type)
+          route << RouteElement.new(current.parent_key, type: current.fragment_type)
           current = current.parent
         end
         route.reverse

data/lib/depth/route_element.rb

@@ -22,9 +22,9 @@ module Depth
         case el
         when Array
           type = el.count > 1 ? el[1] : :hash
-          RouteElement.new(route_el[0], type: type)
+          RouteElement.new(el[0], type: type)
         when Hash
-          key_or_index = el.fetch(:key, el.fetch(:index))
+          key_or_index = el.fetch(:key) { el.fetch(:index) }
           RouteElement.new(key_or_index, type: el.fetch(:type, :hash))
         else
           RouteElement.new(el)

data/lib/depth/version.rb

@@ -1,3 +1,3 @@
 module Depth
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/depth.rb

@@ -1,4 +1,11 @@
-require 'depth/version'
+require_relative './depth/version'
 
 module Depth
 end
+
+require_relative './depth/enumeration/enumerable'
+require_relative './depth/enumeration/node'
+require_relative './depth/actions'
+require_relative './depth/traverser'
+require_relative './depth/route_element'
+require_relative './depth/complex_hash'

data/spec/depth/actions_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+module Depth
+  RSpec.describe Actions do
+
+    let(:actions_class) do
+      Class.new do
+        include Actions
+        attr_reader :base
+        def initialize(base)
+          @base = base
+        end
+      end
+    end
+
+    let(:hash) do
+      { '$and' => [
+        { '#weather' => { 'something' => [] } },
+        { '#weather' => { 'something' => [] } },
+        { '#weather' => { 'something' => [] } },
+        { '$or' => [
+          { '#otherfeed' => {'thing' => [] } },
+        ]}
+      ]}
+    end
+
+    subject { actions_class.new(hash) }
+
+    describe '#set' do
+      it 'should let me set an existing value' do
+        route = [['$and', :array], [0, :hash],
+                 ['#weather', :hash], ['something', :array]]
+        expect do
+          subject.set(route, :test)
+        end.to change { hash['$and'][0]['#weather']['something'] }.to(:test)
+      end
+
+      it 'should let me set a new value' do
+        route = [['$rargh', :array], [0, :hash],
+                 ['#weather', :hash], ['something', :array]]
+        subject.set(route, :test)
+        expect(hash['$rargh'][0]['#weather']['something']).to eq :test
+      end
+    end
+
+    describe '#delete' do
+      context 'when in a hash' do
+        let(:route) do
+          ['$and', 1, '#weather']
+        end
+
+        it 'should let me delete a route endpoint' do
+          expect do
+            subject.delete(route)
+          end.to change { hash['$and'][1].empty? }.to(true)
+        end
+      end
+
+      context 'when in an array' do
+        let(:route) do
+          ['$and', 1]
+        end
+
+        it 'should let me delete a route endpoint' do
+          expect do
+            subject.delete(route)
+          end.to change { hash['$and'].count }.by(-1)
+        end
+      end
+    end
+
+    describe '#alter' do
+      let(:route) do
+        [['$and', :array], [0, :hash], ['#weather', :hash], ['something', :array]]
+      end
+
+      it 'should let me change a key' do
+        expect do
+          subject.alter(route, key: 'blah')
+        end.to change { hash['$and'][0]['#weather'].keys }.to ['blah']
+      end
+
+      it 'should let me change a value' do
+        expect do
+          subject.alter(route, value: 'rargh')
+        end.to change { hash['$and'][0]['#weather']['something'] }.to 'rargh'
+      end
+
+      context 'when changing key and value' do
+        it 'should set the new value' do
+          expect do
+            subject.alter(route, key: 'blah', value: 'rargh')
+          end.to change { hash['$and'][0]['#weather']['blah'] }.to 'rargh'
+        end
+
+        it 'should delete the old key' do
+          expect do
+            subject.alter(route, key: 'blah', value: 'rargh')
+          end.to change { hash['$and'][0]['#weather'].key?('something') }.to false
+        end
+      end
+    end
+
+    describe '#find' do
+      it 'should let me find an existing value' do
+        route = [['$and', :array], [0, :hash],
+                 ['#weather', :hash], ['something', :array]]
+        expect(subject.find(route)).to eq []
+      end
+
+      it 'should return nil if element does not exist' do
+        route = [['$rargh', :array], [0, :hash],
+                 ['#weather', :hash], ['something', :array]]
+        expect(subject.find(route)).to be_nil
+      end
+    end
+  end
+end

data/spec/depth/complex_hash_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Depth
+  RSpec.describe ComplexHash do
+    let(:hash) do
+      { '$and' => [
+        { '#weather' => { 'something' => [] } },
+        { '#weather' => { 'something' => [] } },
+        { '#weather' => { 'something' => [] } },
+        { '$or' => [
+          { '#otherfeed' => {'thing' => [] } },
+        ]}
+      ]}
+    end
+
+    subject { described_class.new(hash) }
+
+    describe '#base' do
+      it 'should return the underlying hash' do
+        expect(subject.base).to eq hash
+      end
+    end
+
+    describe '#to_h' do
+      it 'should be aliased to base' do
+        expect(subject.to_h).to be subject.base
+      end
+    end
+  end
+end

data/spec/depth/enumerable_spec.rb

@@ -0,0 +1,217 @@
+
+require 'spec_helper'
+require 'pry-byebug'
+
+module Depth::Enumeration
+  RSpec.describe Enumerable do
+
+    let(:enumerable_class) do
+      Class.new do
+        include Depth::Actions
+        include Depth::Enumeration::Enumerable
+        attr_reader :base
+        def initialize(base)
+          @base = base
+        end
+      end
+    end
+
+    let(:hash) do
+      { '$and' => [
+        { '#weather' => { 'something' => [] } },
+        { '$or' => [
+          { '#otherfeed' => {'thing' => [] } },
+        ]}
+      ]}
+    end
+
+    subject { enumerable_class.new(hash) }
+
+    describe '#each_with_object' do
+      it "performs as you'd expect reduce to" do
+        keys = subject.each_with_object([]) do |key, fragment, obj|
+          obj << key if key.is_a?(String)
+        end
+        expected = ['something', '#weather', 'thing', '#otherfeed', '$or', '$and']
+        expect(keys).to eq expected
+      end
+    end
+
+    describe '#reduce' do
+      it "performs as you'd expect reduce to" do
+        keys = subject.reduce(0) do |sum, key, fragment|
+          sum += (key.is_a?(String) ? 1 : 0)
+        end
+        expect(keys).to eq 6
+      end
+    end
+
+    shared_examples 'it maps changing self' do
+      let(:map_block) { proc { |x| x } }
+      let(:alter_map_block) { proc { |x| 'rarg' } }
+
+      it 'should return self' do
+        result = subject.send(map_message, &map_block)
+        expect(result).to be subject
+      end
+
+      context 'with alteration' do
+        it 'should change base' do
+          expect do
+            subject.send(map_message, &alter_map_block)
+          end.to change { subject.base }
+        end
+      end
+
+      context 'without alteration' do
+        it 'should not change contents' do
+          expect do
+            subject.send(map_message, &map_block)
+          end.to_not change { subject.base }
+        end
+      end
+    end
+
+    describe '#map!' do
+      it_behaves_like 'it maps changing self' do
+        let(:map_message) { 'map!' }
+        let(:map_block) { proc { |x, y| [x, y] } }
+        let(:alter_map_block) do
+          proc { |k, v| 
+            next [k, v] unless k.is_a?(String)
+            ["#{k}rargh", v]
+          }
+        end
+      end
+    end
+
+    describe '#map_keys!' do
+      it_behaves_like 'it maps changing self' do
+        let(:map_message) { 'map_keys!' }
+        let(:alter_map_block) do
+          proc { |k|
+            next k unless k.is_a?(String)
+            "#{k}Altered"
+          }
+        end
+      end
+    end
+
+    describe '#map_values!' do
+      it_behaves_like 'it maps changing self' do
+        let(:map_message) { 'map_values!' }
+      end
+    end
+
+    shared_examples 'it maps to a new object' do
+      let(:map_block) { proc { |x| x } }
+      it 'should return a new object' do
+        result = subject.send(map_message, &map_block)
+        expect(result).to_not be subject
+      end
+
+      it 'should return an object of the same class' do
+        result = subject.send(map_message, &map_block)
+        expect(result.class).to be subject.class
+      end
+
+      context 'without alteration' do
+        it 'should return an object with the same contents' do
+          result = subject.send(map_message, &map_block)
+          expect(result.base).to eq subject.base
+        end
+      end
+    end
+
+    describe '#map' do
+      it_behaves_like 'it maps to a new object' do
+        let(:map_message) { :map }
+        let(:map_block) { proc { |x, y| [x, y] } }
+      end
+
+      context 'with alteration' do
+        let(:result) do
+          subject.map do |k, v|
+            next [k, v] unless k.is_a?(String)
+            ["#{k}Altered", 'redacted']
+          end
+        end
+
+        it 'should differ in the expected fashion' do
+          expected =  { "$andAltered" => 'redacted' }
+          expect(result.base).to eq expected
+        end
+      end
+    end
+
+    describe '#map_keys' do
+      it_behaves_like 'it maps to a new object' do
+        let(:map_message) { :map_keys }
+      end
+
+      context 'with alteration' do
+        let(:result) do
+          subject.map_keys do |k|
+            next k unless k.is_a?(String)
+            "#{k}Altered"
+          end
+        end
+
+        it 'should differ in the expected fashion' do
+          expected =  { "$andAltered" => [
+            { "#weatherAltered" => { "somethingAltered" => [] } },
+            { "$orAltered" => [ { "#otherfeedAltered" => { "thingAltered" => [] } } ] } ]
+          }
+          expect(result.base).to eq expected
+        end
+      end
+    end
+
+    describe '#map_values' do
+      it_behaves_like 'it maps to a new object' do
+        let(:map_message) { :map_values }
+      end
+
+      context 'with alteration' do
+        let(:result) do
+          subject.map_values do |f|
+            'altered' if f.is_a?(Hash)
+          end
+        end
+
+        it 'should differ in the expected fashion' do
+          expected = { "$and" => [ 'altered', 'altered' ] }
+          expect(result.base).to eq expected
+        end
+
+        it 'should return an object with the different contents' do
+          expect(result.base).to_not eq subject.base
+        end
+      end
+
+    end
+
+    describe '#each' do
+      it 'should sort through all keys and values' do
+        enumerated = []
+        subject.each do |key, fragment|
+          enumerated << [key, fragment]
+        end
+        expected = [
+          ['something', []],
+          ['#weather',  { 'something' => [] }],
+          [0,  { '#weather' => {  'something' => []  }}],
+          ['thing', []],
+          ['#otherfeed', { 'thing' => [] }],
+          [0, { '#otherfeed' => { 'thing' => [] } }],
+          ['$or', [{ '#otherfeed' => { 'thing' => [] } }]],
+          [1, { '$or' => [{ '#otherfeed' => { 'thing' => [] } }] }],
+          ['$and', [{ '#weather' => {  'something' => []  }},
+                   { '$or' => [{ '#otherfeed' => { 'thing' => [] } }] }]]
+        ]
+        expect(enumerated).to eq expected
+      end
+    end
+
+  end
+end

data/spec/depth/route_element_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+module Depth
+  RSpec.describe RouteElement do
+    describe '::convert' do
+      let(:el) { nil }
+      let(:result) { described_class.convert(el) }
+      context 'with any random thing' do
+        let(:el) { 4 }
+        it 'should set the type hash' do
+          expect(result.type).to eq :hash
+        end
+
+        it 'should set the key as the element' do
+          expect(result.key).to eq el
+        end
+      end
+
+      context 'with a hash' do
+        let(:el) { { key: 'x', type: :array } }
+
+        it 'should set the type as the passed type' do
+          expect(result.type).to eq el.fetch(:type)
+        end
+
+        it 'should set the key as the passed key' do
+          expect(result.key).to eq el.fetch(:key)
+        end
+
+        context 'with no type' do
+          let(:el) { { key: 'x' } }
+
+          it 'should set the type hash' do
+            expect(result.type).to eq :hash
+          end
+        end
+
+        context 'with index instead of key' do
+          let(:el) { { index: 'x', type: :array } }
+
+          it 'should set the key as the passed index' do
+            expect(result.key).to eq el.fetch(:index)
+          end
+        end
+      end
+
+      context 'with an array with' do
+        context 'with two elements' do
+          let(:el) { ['x', :array] }
+
+          it 'should set the type as the second element' do
+            expect(result.type).to eq el[1]
+          end
+
+          it 'should set the key as the first element' do
+            expect(result.key).to eq el[0]
+          end
+        end
+
+        context 'with one element' do
+          let(:el) { ['x'] }
+
+          it 'should set the type hash' do
+            expect(result.type).to eq :hash
+          end
+
+          it 'should set the key as the element' do
+            expect(result.key).to eq el[0]
+          end
+        end
+      end
+
+      context 'with a route element' do
+        let(:el) { RouteElement.new('x') }
+
+        it 'should return the element' do
+          expect(result).to be el
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,72 @@
+require 'simplecov'
+SimpleCov.start
+require './lib/depth'
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: depth
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Max
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-18 00:00:00.000000000 Z
+date: 2015-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -88,6 +88,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -101,6 +102,11 @@ files:
 - lib/depth/route_element.rb
 - lib/depth/traverser.rb
 - lib/depth/version.rb
+- spec/depth/actions_spec.rb
+- spec/depth/complex_hash_spec.rb
+- spec/depth/enumerable_spec.rb
+- spec/depth/route_element_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/maxdupenois/depth
 licenses:
 - MIT
@@ -125,4 +131,9 @@ rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Depth is a utility gem for dealing with nested hashes and arrays
-test_files: []
+test_files:
+- spec/depth/actions_spec.rb
+- spec/depth/complex_hash_spec.rb
+- spec/depth/enumerable_spec.rb
+- spec/depth/route_element_spec.rb
+- spec/spec_helper.rb