hash_op 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b2933aa0df964cd1340e8e6ee1ddb7d693b4ee88
-  data.tar.gz: 14fecfc284ef874329d595191e1e00608b36817a
+  metadata.gz: e4ee4ebeea9d4222628d2e8bc1a35ac27ff6b219
+  data.tar.gz: 9cc047ece2b3c87a1baf144f17f3a3434da43afc
 SHA512:
-  metadata.gz: be9847903c1c4e2fb2ed8e7ce934a2b5d7ecdd6e4e45a047ae20efd7632ff8924ec3f5dde5c8c21015c7036b452f0c363decddc8b006affdf994f0bede712c77
-  data.tar.gz: 3d8c64ef1ab7dbc28787043071ee3e171ad1cccee96943bbafd198830661cab9c26c660c684946756d42721cb50fb2db5de2f9ccc5711ede354dd6ad064dfa37
+  metadata.gz: bb145f094b7bd06a0f77ad34b81e0b674d6bb74daa5358a1b60655dc171be67e1113ce39980aee0a99dd26aafaf289e8a04c293930ebebaf722a874868c8fd7f
+  data.tar.gz: 302dede0a9005b1284bb3d405e35937defebc45ad6744f635b7bcb8b15a351460ec43487031a46e6439ff795296fb8da87c3c4571691b0f690e78ce32ab93fec

data/.codeclimate.yml

@@ -0,0 +1,4 @@
+languages:
+  Ruby: true
+# exclude_paths:
+# - "foo/bar.rb"

data/.rubocop.yml

@@ -0,0 +1,12 @@
+Metrics/LineLength:
+  Max: 120
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+Style/EmptyLinesAroundBlockBody:
+  Enabled: false
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+Style/AlignParameters:
+  EnforcedStyle: with_fixed_indentation

data/Gemfile

@@ -3,4 +3,6 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in hash_op.gemspec
 gemspec
 
-gem "coveralls", require: false
+group :test do
+  gem "coveralls", require: false
+end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hash_op (0.1.0)
+    hash_op (0.2.0)
       activesupport
 
 GEM
@@ -85,4 +85,4 @@ DEPENDENCIES
   rspec
 
 BUNDLED WITH
-   1.10.3
+   1.10.6

data/README.md

@@ -3,7 +3,7 @@
 
 A Ruby library of functions to access and manipulate hash data structures.
 
-[![Build Status](https://travis-ci.org/travis-ci/travis-web.svg?branch=master)](https://travis-ci.org/travis-ci/travis-web)
+[![Build Status](https://travis-ci.org/rchampourlier/hash_op.svg?branch=master)](https://travis-ci.org/rchampourlier/hash_op)
 [![Code Climate](https://codeclimate.com/github/rchampourlier/hash_op/badges/gpa.svg)](https://codeclimate.com/github/rchampourlier/hash_op)
 [![Coverage Status](https://coveralls.io/repos/rchampourlier/hash_op/badge.svg)](https://coveralls.io/r/rchampourlier/hash_op)
 
@@ -27,15 +27,13 @@ Or install it yourself as:
 
 ## Available operations
 
-_See specs for more details on each operation._
-
 ### Deep Access
 
 ```ruby
-HashOp::DeepAccess.fetch({a: {b: {c: 1}}}, :'a.b.c')
+HashOp::Deep.fetch({a: {b: {c: 1}}}, :'a.b.c')
 => 1
 
-HashOp::DeepAccess.merge({ a: { b: { c: 1 } } }, :'a.b.c', 2)
+HashOp::Deep.merge({ a: { b: { c: 1 } } }, :'a.b.c', 2)
 => {
   :a => {
     :b => {
@@ -44,7 +42,264 @@ HashOp::DeepAccess.merge({ a: { b: { c: 1 } } }, :'a.b.c', 2)
   }
 }
 ```
-TODO: complete with other available operations
+
+### Filter
+
+```ruby
+hashes = [
+  { value: 123, regexp: "itsamatch", proc: "1+1" },
+  { value: 123, regexp: "abcdef", proc: "1+2" },
+  { value: 234, regexp: "abcdef", proc: "1+2" }
+]
+criteria = {
+  path: :value,
+  matching_object: 123
+}
+HashOp::Filter.filter(hashes, { value: 123 })
+=> [
+  [0] {
+      :proc => "1+1",
+    :regexp => "itsamatch",
+     :value => 123
+  },
+  [1] {
+      :proc => "1+2",
+    :regexp => "abcdef",
+     :value => 123
+  }
+]
+HashOp::Filter.filter(hashes, { value: 123, regexp: /match/ })
+=> [
+  [0] {
+      :proc => "1+1",
+    :regexp => "itsamatch",
+     :value => 123
+  }
+]
+HashOp::Filter.filter(hashes, { proc: ->(x) { eval(x) == 2 } })
+=> [
+  [0] {
+      :proc => "1+1",
+    :regexp => "itsamatch",
+     :value => 123
+  }
+]
+
+Internally, `HashOp::Filter::filter` uses
+`HashOp::Filter::match?(hash, criteria)` which you can
+use too.
+```
+
+### Mapping
+
+```ruby
+hash = {a: { b: { c: 1 } } }
+mapping = { r: { path: :'a.b.c' } }
+HashOp::Mapping.apply_mapping(hash, mapping)
+=> {
+  :r => 1
+}
+
+hash = {
+  raw: { deep: 'raw_value' },
+  time: '2015-07-06 03:37:13 +0200',
+  mapped_hash: {
+    raw: { deep: 'deep_raw_value' },
+    time: '2014-07-06 03:37:13 +0200'
+  },
+  parseable_string: 'a=1;b=2;t=2013-07-06 03:37:13 +0200',
+  array: [
+    '2015-07-06 03:37:13 +0200',
+    '2014-07-06 03:37:13 +0200',
+    '2013-07-06 03:37:13 +0200'
+  ]
+}
+mapping = {
+  raw: { path: :'raw.deep' },
+  time: { path: :time, type: :time },
+  raw_from_mapped_hash: {
+    path: :'mapped_hash.raw.deep',
+  },
+  time_from_mapped_hash: {
+    path: :'mapped_hash.time',
+    type: :time
+  },
+  values_from_parseable_string: {
+    path: :parseable_string,
+    type: :parseable_string,
+    parsing_mapping: {
+      value: { regexp: 'a=(\d)+;' },
+      time: {
+        regexp: 't=(.*)$',
+        type: :time
+      }
+    }
+  },
+  times_from_array: {
+    type: :array,
+    path: :array,
+    item_mapping: { type: :time }
+  }
+}
+HashOp::Mapping.apply_mapping(hash, mapping)
+=> {
+                           :raw => "raw_value",
+          :raw_from_mapped_hash => "deep_raw_value",
+                          :time => 2015-07-06 03:37:13 +0200,
+         :time_from_mapped_hash => 2014-07-06 03:37:13 +0200,
+              :times_from_array => [
+    [0] 2015-07-06 03:37:13 +0200,
+    [1] 2014-07-06 03:37:13 +0200,
+    [2] 2013-07-06 03:37:13 +0200
+  ],
+  :values_from_parseable_string => {
+     :time => 2013-07-06 03:37:13 +0200,
+    :value => "1"
+  }
+}
+```
+
+### Grouping
+
+```ruby
+hashes = [
+  {
+    grouping_path: 'A',
+    value: 1,
+    node: { 'deep_grouping_path': 'AA' }
+  },
+  {
+    grouping_path: 'B',
+    value: 2,
+    node: { 'deep_grouping_path': 'BB' }
+  },
+  {
+    grouping_path: 'A',
+    value: 3,
+    node: { 'deep_grouping_path': 'AB' }
+  },
+  {
+    grouping_path: 'A',
+    value: 4,
+    node: { 'deep_grouping_path': 'AA' }
+  }
+]
+HashOp::Grouping.group_on_path(hashes, :grouping_path)
+=> {
+  "A" => [
+    [0] {
+      :grouping_path => "A",
+               :node => {
+        :deep_grouping_path => "AA"
+      },
+              :value => 1
+    },
+    [1] {
+      :grouping_path => "A",
+               :node => {
+        :deep_grouping_path => "AB"
+      },
+              :value => 3
+    },
+    [2] {
+      :grouping_path => "A",
+               :node => {
+        :deep_grouping_path => "AA"
+      },
+              :value => 4
+    }
+  ],
+  "B" => [
+    [0] {
+      :grouping_path => "B",
+               :node => {
+        :deep_grouping_path => "BB"
+      },
+              :value => 2
+    }
+  ]
+}
+HashOp::Grouping.group_on_path(hashes, :'node.deep_grouping_path')
+=> {
+  "AA" => [
+    [0] {
+      :grouping_path => "A",
+               :node => {
+        :deep_grouping_path => "AA"
+      },
+              :value => 1
+    },
+    [1] {
+      :grouping_path => "A",
+               :node => {
+        :deep_grouping_path => "AA"
+      },
+              :value => 4
+    }
+  ],
+  "AB" => [
+    [0] {
+      :grouping_path => "A",
+               :node => {
+        :deep_grouping_path => "AB"
+      },
+              :value => 3
+    }
+  ],
+  "BB" => [
+    [0] {
+      :grouping_path => "B",
+               :node => {
+        :deep_grouping_path => "BB"
+      },
+              :value => 2
+    }
+  ]
+}
+HashOp::Grouping.group_on_paths(hashes, [:grouping_path, :'node.deep_grouping_path'])
+=> {
+  "A" => {
+    "AA" => [
+      [0] {
+        :grouping_path => "A",
+                 :node => {
+          :deep_grouping_path => "AA"
+        },
+                :value => 1
+      },
+      [1] {
+        :grouping_path => "A",
+                 :node => {
+          :deep_grouping_path => "AA"
+        },
+                :value => 4
+      }
+    ],
+    "AB" => [
+      [0] {
+        :grouping_path => "A",
+                 :node => {
+          :deep_grouping_path => "AB"
+        },
+                :value => 3
+      }
+    ]
+  },
+  "B" => {
+    "BB" => [
+      [0] {
+        :grouping_path => "B",
+                 :node => {
+          :deep_grouping_path => "BB"
+        },
+                :value => 2
+      }
+    ]
+  }
+}
+```
+
+_See specs for more details on each operation and operations not documented here._
 
 ## Development
 
@@ -55,3 +310,15 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/rchampourlier/hash_op. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) [code of conduct](CODE_OF_CONDUCT.md).
+
+## Revisions
+
+### 0.2.0
+
+- Removed some operations that made no real sense (`Math.sum` and `Math.sum_two`).
+- Renamed `DeepAccess` to `Deep`.
+- Renamed `Merge.merge` to `Merge.flat` and `Merge.merge_by_group` to `Merge.by_group`.
+
+### 0.1.0
+
+Initial version

data/lib/hash_op/{deep_access.rb → deep.rb}

@@ -5,19 +5,19 @@ require 'active_support/all'
 # through a path in the form of 'a.b.c' or an array
 # of segments ['a', 'b', 'c'].
 module HashOp
-  module DeepAccess
+  module Deep
 
     # Examples:
     #     h = {a: {b: {c: 1}}}
-    #     HashOp::DeepAccess.fetch(h, :a) # => {:b=>{:c=>1}}
-    #     HashOp::DeepAccess.fetch(h, :'a.b') # => {:c=>1}
-    #     HashOp::DeepAccess.fetch(h, :'a.b.c') # => 1
-    #     HashOp::DeepAccess.fetch(h, [:a]) # => {:b=>{:c=>1}}
-    #     HashOp::DeepAccess.fetch(h, [:a, :b, :c]) # => 1
-    #     HashOp::DeepAccess.fetch(h, :'b.c.a') # => nil
+    #     HashOp::Deep.fetch(h, :a) # => {:b=>{:c=>1}}
+    #     HashOp::Deep.fetch(h, :'a.b') # => {:c=>1}
+    #     HashOp::Deep.fetch(h, :'a.b.c') # => 1
+    #     HashOp::Deep.fetch(h, [:a]) # => {:b=>{:c=>1}}
+    #     HashOp::Deep.fetch(h, [:a, :b, :c]) # => 1
+    #     HashOp::Deep.fetch(h, :'b.c.a') # => nil
     #
     def fetch(hash, path)
-      raise 'First argument must be an Hash' unless hash.is_a? Hash
+      fail ArgumentError, 'First argument must be an Hash' unless hash.is_a?(Hash)
       if path.class.in? [String, Symbol]
         fetch_with_deep_key(hash, path)
       elsif path.is_a? Array
@@ -28,8 +28,16 @@ module HashOp
     end
     module_function :fetch
 
+    # Examples:
+    #   h = {}
+    #   h = HashOp::Deep.merge(h, :a, 1)
+    #   => { :a => 1 }
+    #   h = HashOp::Deep.merge(h, :'a.b', 2)
+    #   => { :a => { :b => 2 }
+    #   h = HashOp::Deep.merge(h, :b, 3)
+    #   => { :a => { :b => 2 }, :b => 3 }
     def merge(hash, path, value)
-      raise 'First argument must be an Hash' unless hash.is_a? Hash
+      fail ArgumentError, 'First argument must be an Hash' unless hash.is_a? Hash
       if path.class.in? [String, Symbol]
         merge_with_deep_key(hash, path, value)
       elsif path.is_a? Array
@@ -40,6 +48,24 @@ module HashOp
     end
     module_function :merge
 
+    # Example:
+    #   hash = { a: { :b => 1, 'c' => 2 }, d: 0 }
+    #   HashOp::Deep.paths(hash)
+    #   => [[:a, :b], [:a, 'c' ], [:d]]
+    def paths(hash)
+      r = []
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          paths(value).each do |deep_key|
+            r << [key] + Array(deep_key)
+          end
+        else r << Array(key)
+        end
+      end
+      r.uniq
+    end
+    module_function :paths
+
     private
 
     def fetch_with_deep_key(hash, deep_key)

data/lib/hash_op/filter.rb

@@ -1,4 +1,4 @@
-require 'hash_op/deep_access'
+require 'hash_op/deep'
 
 # Performs filtering operation on hash or array of hashes
 module HashOp
@@ -7,6 +7,8 @@ module HashOp
     # Filters an array of hashes according to criteria
     # on the values of each hash.
     #
+    # Check the README for examples.
+    #
     # @param [Array] hashes array of hashes to be filtered
     # @param [Hash] criteria the method uses ::match?, see
     #   definition for more details
@@ -24,17 +26,17 @@ module HashOp
     # @param [Hash] hash the hash to be filtered
     # @param [String, Symbol] the path of the array of hashes
     #   inside hash to be filtered. Accessed through
-    #   HashOp::DeepAccess (path like 'path.to.some.key').
+    #   HashOp::Deep (path like 'path.to.some.key').
     # @param [Hash] criteria to filter on (performed through
     #   ::filter, so see the method for more details)
     # @return [Hash] the hash with values in array at path
     #   filtered according to criteria
     def filter_deep(hash, path, criteria = {})
-      array = HashOp::DeepAccess.fetch hash, path
+      array = HashOp::Deep.fetch hash, path
       raise "Can\'t filter hash at path \"#{path}\", value is not an array" unless array.is_a?(Array)
 
       filtered_array = filter(array, criteria)
-      HashOp::DeepAccess.merge hash, path, filtered_array
+      HashOp::Deep.merge hash, path, filtered_array
     end
     module_function :filter_deep
 
@@ -43,7 +45,7 @@ module HashOp
     #   each criteria is an hash
     #   { path => matching_object }, where:
     #     - path [String, Symbol] is used to access the value
-    #       in the filtered object (through HashOp::DeepAccess::fetch)
+    #       in the filtered object (through HashOp::Deep::fetch)
     #     - matching_object [Object] the object defining the
     #       match:
     #       * a Proc which will be called with the value and
@@ -54,20 +56,18 @@ module HashOp
     #       * any other value will be matched against the
     #         equality operator.
     def match?(hash, criteria)
-      raise ArgumentError.new('First argument must be an Hash') unless hash.is_a?(Hash)
+      unless hash.is_a?(Hash)
+        fail ArgumentError, 'First argument must be an Hash'
+      end
       return true if criteria.blank?
 
       criteria.map do |path, matching_object|
-        value = HashOp::DeepAccess.fetch(hash, path)
-
+        value = HashOp::Deep.fetch(hash, path)
         case
-
         when matching_object.is_a?(Proc)
           matching_object.call(value)
-
         when matching_object.is_a?(Regexp)
-          !!(value =~ matching_object)
-
+          (value =~ matching_object).present?
         else value == matching_object
         end
       end.uniq == [true]

data/lib/hash_op/grouping.rb

@@ -1,4 +1,4 @@
-require 'hash_op/deep_access'
+require 'hash_op/deep'
 
 # A module to perform group operations on hashes.
 module HashOp
@@ -10,7 +10,7 @@ module HashOp
     # @return [Hash]
     def group_on_path(hashes, path)
       hashes.inject({}) do |result, hash|
-        value_at_path = HashOp::DeepAccess.fetch(hash, path)
+        value_at_path = HashOp::Deep.fetch(hash, path)
         result[value_at_path] ||= []
         result[value_at_path] << hash
         result

data/lib/hash_op/mapping.rb

@@ -1,4 +1,4 @@
-require 'hash_op/deep_access'
+require 'hash_op/deep'
 
 # A module to perform mapping from hash to hash.
 module HashOp
@@ -9,20 +9,35 @@ module HashOp
     #   mapping (see example below)
     #   A mapping hash is:
     #     a_key [String or Symbol] => a_mapping_item [Hash]
-    #   A mapping item is:
-    #     path: [String or Symbol] the path to the value
-    #     type: [:time or :array]
-    #     item_mapping: [Hash] for a mapping item whose type
-    #       is :array when the array items are hashes to be
-    #       mapped again. This mapping can be done with any
-    #       level of recursion.
+    #   A mapping item is composed of:
+    #     - path: [String or Symbol] the path to the value
+    #     - type: [Symbol] defines how the item will be processed
+    #       before being added to the result
+    #       - `raw` (defaults, if no type specified): the value
+    #         is passed with no transformation
+    #       - `time`: the value is parsed using `Time.parse`
+    #         (if the parse fails, nil is passed in the result,
+    #         no exception raised)
+    #       - `mapped_hash`: the value is mapped recursively,
+    #         using the `mapping` key as the mapping
+    #       - `parseable_string`: the string value is analyzed
+    #         using regexps and each value extracted by a regexp
+    #         can be recursively processed using mappings
+    #         applicable to strings (e.g. time); the mapping
+    #         to use for the parsing is defined in
+    #         `parsing_mapping` (see the README for an example)
+    #       - `array`: recursively apply a mapping over each
+    #         item in the array; the mapping for each item is
+    #         defined in `item_mapping`
+    #     - mapping: for a mapping item of type `mapped_hash`
+    #     - parsing_mapping: for a mapping item of type
+    #       `parseable_string`
+    #     - item_mapping: for a mapping item of type `array`
     #
     # Example of a mapping hash:
     # {
-    #   int:  { path: :'root.integer' },
-    #   str:  { path: :'root.string' },
+    #   raw:  { path: :'root.value' },
     #   time: { path: :'root.deep_1.deep_2.time', type: :time },
-    #   strings: { path: :'root.array_of_strings' },
     #   mapped_hashes: {
     #     path: :'root.array_of_mapped_hashes',
     #     type: :array,
@@ -38,7 +53,7 @@ module HashOp
         mapping_item = mapping[key]
         path = mapping_item[:path]
         raise "path not found in mapping item #{mapping_item}" if path.nil?
-        raw = HashOp::DeepAccess.fetch(hash, path)
+        raw = HashOp::Deep.fetch(hash, path)
         processed = process_with_mapping_item(raw, mapping_item)
         mapped_hash[key] = processed
         mapped_hash

data/lib/hash_op/math.rb

@@ -1,69 +1,52 @@
-require 'hash_op/deep_access'
+require 'hash_op/deep'
 
 # A set of functions to perform mathematical operations
 # on Hashes.
 module HashOp
   module Math
 
-    # @param hashes [Array] of Hash instances
-    # @return [Hash] summing values of the same key
-    def sum(*hashes)
-      hashes.flatten!
-      case hashes.length
-      when 0 then {}
-      when 1 then hashes.first
-      when 2 then sum_two(*hashes)
-      else
-        sum(*[sum_two(*hashes[0..1])] + hashes[2..-1])
-      end
-    end
-    module_function :sum
-
-    def sum_two(hash_a, hash_b)
-      hash_b.each do |key, hash_b_value|
-        if hash_a[key]
-          hash_a[key] += hash_b_value
-        else
-          hash_a[key] = hash_b_value
-        end
-      end
-      hash_a
-    end
-    module_function :sum_two
-
     # Sum values in an array of hashes by grouping on a given
     # key.
     #
     # Example:
     #   hashes = [
-    #     { group: :a, value: 1 },
-    #     { group: :a, value: 1 },
-    #     { group: :b, value: 1 }
+    #     { group_1: :a, group_2: :a, value_1: 1, value_2: 1 },
+    #     { group_1: :a, group_2: :b, value_1: 1, value_2: 2 },
+    #     { group_1: :a, group_2: :b, value_1: 1, value_2: 2 },
+    #     { group_1: :b, group_2: :c, value_1: 1, value_2: 3 }
+    #   ]
+    #   HashOp::Math.sum_on_groups(hashes,
+    #     [:group_1], [:value_1, :value_2]
+    #   )
+    #   => [
+    #     { group_1: :a, value_1: 3, value_2: 5 },
+    #     { group_1: :b, value_1: 1, value_2: 3 }
+    #   ]
+    #   HashOp::Math.sum_on_groups(hashes,
+    #     [:group_1, :group_2], [:value_1, :value_2]
+    #   )
+    #   => [
+    #     { group_1: :a, group_2: :a, value_1: 1, value_2: 1 },
+    #     { group_1: :a, group_2: :b, value_1: 2, value_2: 4 },
+    #     { group_1: :b, group_2: :c, value_1: 1, value_2: 3 }
     #   ]
-    #   HashOp::Math.sum_on_groups(hashes, :group, :value)
-    #   # => [
-    #   #   { group: :a, value: 2 },
-    #   #   { group: :b, value: 1 }
-    #   # ]
     #
     # @param hashes [Array] the hashes to be summed
     # @param group_key [Object] the key to use to group items on
     # @param value_key [Object] the key of the values to sum
     # @return [Array]
-    def sum_on_groups(hashes, group_key, value_key)
-      work_hash = hashes.inject({}) do |work, hash|
-        if work[hash[group_key]].nil?
-          work[hash[group_key]] = {
-            group_key => hash[group_key],
-            value_key => hash[value_key]
-          }
-        else
-          work[hash[group_key]][value_key] += hash[value_key]
+    def sum_on_groups(hashes, grouping_paths, value_paths)
+      grouped_hashes = Grouping.group_on_paths(hashes, grouping_paths)
+      group_paths = Deep.paths(grouped_hashes)
+      result = group_paths.map do |group_path|
+        group_hashes = HashOp::Deep.fetch(grouped_hashes, group_path)
+        group_values = value_paths.map do |value_path|
+          group_value = HashOp::Math.sum_at_path(group_hashes, value_path)
+          { value_path => group_value }
         end
-        work
+        Hash[[grouping_paths, group_path].transpose].merge(Merge.flat(group_values))
       end
-      work_hash.values
-    end
+  end
     module_function :sum_on_groups
 
     # Sum values for the specified hashes at the specified path.
@@ -76,7 +59,7 @@ module HashOp
     #
     def sum_at_path(hashes, path, zero = 0)
       hashes.inject(zero) do |sum, hash|
-        value = HashOp::DeepAccess.fetch(hash, path) || zero
+        value = HashOp::Deep.fetch(hash, path) || zero
         sum + value
       end
     end
@@ -85,14 +68,14 @@ module HashOp
     # @param [Array] hashes array of Hash
     # @param [String, Symbol] path to deep value in each hash
     def deep_min(hashes, path)
-      hashes.map { |hash| HashOp::DeepAccess.fetch hash, path }.min
+      hashes.map { |hash| HashOp::Deep.fetch hash, path }.min
     end
     module_function :deep_min
 
     # @param [Array] hashes array of Hash
     # @param [String, Symbol] path to deep value in each hash
     def deep_max(hashes, path)
-      hashes.map { |hash| HashOp::DeepAccess.fetch hash, path }.max
+      hashes.map { |hash| HashOp::Deep.fetch hash, path }.max
     end
     module_function :deep_max
   end

data/lib/hash_op/merge.rb

@@ -3,19 +3,19 @@ module HashOp
 
     # Merge all specified hashes by merging the second
     # in the first, the third in the result, and so on.
-    def merge(hashes)
+    def flat(hashes)
       hashes.inject({}) do |result, hash|
         result.merge hash
       end
     end
-    module_function :merge
+    module_function :flat
 
     # Merge hashes by grouping them on the
     # specified key value and merging them all together.
-    def merge_by_group(hashes, key)
+    def by_group(hashes, key)
       groups = hashes.group_by { |h| h[key] }
-      groups.values.map { |g| merge(g) }
+      groups.values.map { |g| flat(g) }
     end
-    module_function :merge_by_group
+    module_function :by_group
   end
 end

data/lib/hash_op/version.rb

@@ -1,3 +1,3 @@
 module HashOp
-  VERSION = "0.1.0"
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_op
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Romain Champourlier
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-06-13 00:00:00.000000000 Z
+date: 2015-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -101,8 +101,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -113,7 +115,7 @@ files:
 - bin/setup
 - hash_op.gemspec
 - lib/hash_op.rb
-- lib/hash_op/deep_access.rb
+- lib/hash_op/deep.rb
 - lib/hash_op/filter.rb
 - lib/hash_op/grouping.rb
 - lib/hash_op/mapping.rb
@@ -140,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: A Ruby library of functions to access and manipulate hash data structures.