re-hash 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a86df189af830efb764480391000e3df8cb7a8ee
+  data.tar.gz: 395cfb542fba02e7a06437c1c03725c9f83409e6
+SHA512:
+  metadata.gz: 2513661d8d0ba04d469a530dae3a62345d5368d5528178e2292af7557463685a9f17c86d3997d52945a9d4e57368ef5010cc18e4e93cfb7c6c49c999d4675456
+  data.tar.gz: 6ee14c245ee4f33f997eba0bb12f7287176f4d291f17cde2f48643f37bc165b28ad66fd22c42f61f84642fb401a254fbef68c202dd6732479ef3918a79663809

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+.vscode
+.ruby-gemset
+.ruby-version

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.1.0
+before_install: gem install bundler -v 1.12.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rehash.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Artem Kuzko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,248 @@
+# Rehash
+
+This gem allows you to transform a hash from one structure to another. For instance,
+to extract deeply nested values from it to a more convenient form with a simple and
+easy-to use mapping. Inspired by [hash_mapper](https://github.com/ismasan/hash_mapper),
+but has a more DRY and robust API.
+
+Do not be confused with Ruby's core `Hash#rehash` method. This gem has nothing to
+do with it and is used solely for mapping values from source hash into another one.
+
+[![build status](https://secure.travis-ci.org/akuzko/rehash.png)](http://travis-ci.org/akuzko/rehash)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 're-hash', require: 'rehash'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install re-hash
+
+## Usage
+
+Considering we have a following hash:
+
+```rb
+hash = {
+  foo: {
+    bar: {
+      baz: 1,
+      bak: 2
+    }
+  },
+  foos: [
+    { bar: { baz: '3-1' } },
+    { bar: { baz: '3-2' } }
+  ],
+  big_foo: {
+    nested: {
+      bar1: { baz: '4-1' },
+      bar2: { baz: '4-2' },
+      bar3: { baz: '4-3' }
+    }
+  },
+  config: [
+    {name: 'important_value', value: 'yes'},
+    {name: 'secondary_value', value: 'no'}
+  ]
+}
+```
+
+### Simple mapping
+
+Simple mapping, provided as a mapping hash, allows to quickly map source hash
+values to new structure:
+
+```rb
+Rehash.map(hash,
+  '/foo/bar/baz'             => '/faz',
+  '/big_foo/nested/bar1/baz' => '/baz1'
+)
+# => {:faz => 1, :baz1 => '4-1'}
+```
+
+### Block usage
+
+`Rehash.map` method yield a `Rehash::Mapper` instance that allows you to apply multiple
+mappings, as well as transform mapped values themselves:
+
+```rb
+Rehash.map(hash) do |m|
+  m.(
+    '/foo/bar/baz' => '/faz',
+    '/foo/bar/bak' => '/fak'
+  )
+  m.('/big_foo/nested/bar1/baz' => '/baz1') do |value|
+    value.to_i
+  end
+  m.('/foos' => '/foos') do |foos|
+    foos.map{ |item| Rehash.map(item, '/bar/baz' => '/value') }
+  end
+end
+# => {:baz1 => 4, faz: 1, fak: 2, :foos => [{:value => '3-1'}, {:value => '3-2'}]}
+```
+
+In case if you need to do any additional manipulations over resulting returned hash,
+you may access it via `Mapper#result` method (i.e. `m.result` in example above)
+
+### Accessing array items
+
+#### By index
+
+It is very easy to map values from items within array by accessing them by index:
+
+```rb
+Rehash.map(hash, '/foos[0]/bar/baz' => '/first_faz')
+# => {:first_faz => '3-1'}
+```
+
+#### By property lookup
+
+It is also possible to access item within array by one of it's properties:
+
+```rb
+Rehash.map(hash, '/config[name:important_value]/value' => '/important')
+# => {:important => 'yes'}
+```
+
+### Refinement (recommended usage)
+
+`Rehash` also implements a `Hash` class refinement, using which is actually
+**a recommended way** of using `re-hash`. Considering that `#map` and `#rehash`
+methods are part of Ruby's Hash core functionality, `Rehash` allows to use
+`#map_with` method for hash mappings.
+
+```rb
+using Rehash
+
+hash.map_with('/foo/bar/baz' => '/faz') # => {:faz => 1}
+# OR:
+hash.map_with do |m|
+  m.('/foo/bar/bak' => '/fak') { |v| v * 2 }
+end
+# => {:fak => 4}
+```
+
+### HashExtension
+
+In case if you don't want to use refinement and want to have `#map_with` method
+globally available, you can extend `Hash` itself with core extension:
+
+```rb
+Hash.send(:include, HashExtension)
+
+{foo: 'baz'}.map_with('/foo' => '/bar') # => {bar: 'baz'}
+```
+
+### Options
+
+`Rehash` uses `'/'` as path delimiter by default, as well as it symbolizes resulting
+keys. To use other options on a distinct `map` or `map_with` calls you have to use block form:
+
+```rb
+Rehash.map(hash, delimiter: '.', symbolize_keys: false) do |m|
+  m.('foo.bam.baz' => 'foo.baz')
+)
+# => {"foo" => {"baz" => 1}}
+```
+
+Or you can set default options globally:
+
+```rb
+Rehash.default_options(delimiter: '.', symbolize_keys: false)
+Rehash.map(hash, 'foo.bam.baz' => 'foo.baz') # => {"foo" => {"baz" => 1}}
+```
+
+### Default value
+
+On mapping, for convenience, you can use `default` option that will be assigned
+to value that is missing at the specified path in the source hash or is `nil`
+*before* it is yielded to the block (if block is given):
+
+```rb
+Rehash.map(hash) do |m|
+  m.('/foo/bar/baz' => '/faz', '/missing' => '/bak', default: 5) do |value|
+    value * 2
+  end
+end
+# => {:faz => 2, :bar => 10}
+```
+
+### Helper methods
+
+`Mapper` instance that is yielded to the block also has a couple of small helper
+methods for dealing with arrays and deeply nested values to make things even more DRY.
+
+- `map_array(from => to, &block)` - used to map an array of items at path `from` to a path `to`,
+  yielding a `Mapper` instance for each item:
+
+```rb
+Rehash.map(hash) do |m|
+  m.map_array('/foos' => '/foos') do |im|
+    im.('/bar/baz' => '/value')
+  end
+  # is the same as:
+  m.('/foos' => '/foos') do |value|
+    value.map do |item|
+      Rehash.map(item, '/bar/baz' => '/value')
+    end
+  end
+end
+```
+
+- `map_hash(from => to, &block)` - yields a `Mapper` instance for a hash located at
+  the path `from` and puts result of mapping to the path defined by `to`:
+
+```rb
+Rehash.map(hash) do |m|
+  m.map_hash('/big_foo/nested' => '/') do |hm|
+    hm.(
+      '/bar1/baz' => '/big_baz1',
+      '/bar2/baz' => '/big_baz2',
+      '/bar3/baz' => '/big_baz3'
+    )
+  end
+  # is the same as:
+  m.(
+    '/big_foo/nested/bar1/baz' => '/big_baz1',
+    '/big_foo/nested/bar2/baz' => '/big_baz2',
+    '/big_foo/nested/bar3/baz' => '/big_baz3'
+  )
+end
+```
+
+- `[](path)` and `[]=(path, value)` - small helper methods that can be called on mapper
+  object when hash is mapped with a block form. `[](path)` can be used to get the value
+  at the `path` **in source hash**, and `[]=(path, value)` can be used to put the `value`
+  at the `path` **in the resulting hash**:
+
+```rb
+Rehash.map(hash) do |m|
+  m['/faz'] = m['/foo/bar/baz']
+  # is essentially the same as:
+  m.('/foo/bar/baz' => '/faz')
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec`
+to run the tests. You can also run `bin/console` for an interactive prompt that will allow
+you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/akuzko/rehash.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rehash"
+
+using Rehash
+
+hash = {
+  foo: {
+    bar: {
+      baz: 1
+    }
+  },
+  other_foo: 2,
+  foos: [
+    { bar: { baz: '3-1' } },
+    { bar: { baz: '3-2' } }
+  ],
+  foos2: [
+    { bar: { baz: '4-1' } },
+    { bar: { baz: '4-2' } }
+  ],
+  big_foo: {
+    nested: {
+      bar1: { baz: '5-1' },
+      bar2: { baz: '5-2' },
+      bar3: { baz: '5-3' }
+    }
+  },
+  items: [6],
+  config: [
+    {name: 'important_value', value: 'yes'},
+    {name: 'secondary_value', value: 'no'}
+  ]
+}
+
+rehash = hash.map_with do |m|
+  m.(
+    '/foo/bar/baz' => '/faz',
+    '/other_foo'   => '/foo',
+    '/items[0]'    => '/first_item'
+  )
+
+  m.('/foos' => '/foos') do |items|
+    items.map { |item| item.map_with('/bar/baz' => '/value') }
+  end
+
+  m.map_array('/foos2' => '/other_foos') do |im|
+    im.('/bar/baz' => '/value')
+  end
+
+  m.map_hash('/big_foo/nested' => '/') do |hm|
+    hm.(
+      '/bar1/baz' => '/big_baz1',
+      '/bar2/baz' => '/big_baz2',
+      '/bar3/baz' => '/big_baz3'
+    )
+  end
+
+  m.('/config[name:important_value]/value' => '/important')
+  m.('/config[name:missing_value]/value' => '/two', default: 2) do |val|
+    val * 2
+  end
+end
+
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rehash.rb

@@ -0,0 +1,26 @@
+require "rehash/version"
+require "rehash/mapper"
+require "rehash/hash_extension"
+require "rehash/refinement"
+
+module Rehash
+  @@default_options = {delimiter: '/'.freeze, symbolize_keys: true}.freeze
+  
+  module_function
+
+  def default_options(value = nil)
+    return @@default_options if value.nil?
+
+    @@default_options = @@default_options.merge(value).freeze
+  end
+
+  def map(hash, opts_or_mapping = {})
+    if block_given?
+      mapper = Mapper.new(hash, default_options.merge(opts_or_mapping))
+      yield mapper
+      mapper.result
+    else
+      Mapper.new(hash).(opts_or_mapping)
+    end
+  end
+end

data/lib/rehash/hash_extension.rb

@@ -0,0 +1,7 @@
+module Rehash
+  module HashExtension
+    def map_with(opts_or_mapping = {}, &block)
+      ::Rehash.map(self, opts_or_mapping, &block)
+    end
+  end
+end

data/lib/rehash/mapper.rb

@@ -0,0 +1,93 @@
+module Rehash
+  class Mapper
+    attr_reader :result
+
+    def initialize(source, opts = Rehash.default_options)
+      @source = source
+      @result = {}
+      @symbolize_keys = opts[:symbolize_keys]
+      @delimiter = opts[:delimiter]
+    end
+
+    def call(mapping, &block)
+      default = mapping.delete(:default) if mapping.key?(:default)
+
+      mapping.each do |from, to|
+        value = get_value(from)
+        value = default if value.nil? && !default.nil?
+        value = yield value if block_given?
+        put_value(to, value)
+      end
+
+      result
+    end
+
+    def [](path)
+      get_value(path)
+    end
+
+    def []=(path, value)
+      put_value(path, value)
+    end
+
+    def map_array(mapping)
+      call(mapping) do |value|
+        value.map do |item|
+          Rehash.map(item) do |item_re|
+            yield item_re
+          end
+        end
+      end
+    end
+
+    def map_hash(mapping)
+      call(mapping) do |value|
+        Rehash.map(value) do |nested_re|
+          yield nested_re
+        end
+      end
+    end
+
+    private
+
+    def get_value(path)
+      path.split(@delimiter).reject(&:empty?).reduce(@source) do |result, key|
+        return if !result
+
+        with_array_access, array_key, index = with_array_access?(key)
+        
+        if with_array_access
+          lookup(result[array_key] || result[array_key.to_sym], index)
+        else
+          result[key] || result[key.to_sym]
+        end
+      end
+    end
+
+    def put_value(path, value)
+      keys = path.split(@delimiter).reject(&:empty?)
+
+      return @result.merge!(value) if keys.length == 0
+
+      keys.each_with_index.reduce(@result) do |res, (key, i)|
+        result_key = @symbolize_keys ? key.to_sym : key
+        if i == keys.length - 1
+          res[result_key] = value
+        else
+          res[result_key] = {}
+        end
+      end
+    end
+
+    def with_array_access?(key)
+      return key =~ /^([^\[\]]+)\[([\d\w\s&$_:-]+)\]$/, $1, $2
+    end
+
+    def lookup(array, index)
+      return array[index.to_i] unless index =~ /^([^:]+):(.+)$/
+      
+      key, value = $1, $2
+      array.find { |item| (item[key] || item[key.to_sym]) == value }
+    end
+  end
+end

data/lib/rehash/refinement.rb

@@ -0,0 +1,7 @@
+module Rehash
+  refine Hash do
+    def map_with(opts_or_mapping = {}, &block)
+      ::Rehash.map(self, opts_or_mapping, &block)
+    end
+  end
+end

data/lib/rehash/version.rb

@@ -0,0 +1,3 @@
+module Rehash
+  VERSION = "0.1.0"
+end

data/rehash.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rehash/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "re-hash"
+  spec.version       = Rehash::VERSION
+  spec.authors       = ["Artem Kuzko"]
+  spec.email         = ["a.kuzko@gmail.com"]
+
+  spec.summary       = %q{Easy-to-use hash values mapping and transformation.}
+  spec.description   = %q{Easy-to-use hash deeply nested values mapping and transformation.}
+  spec.homepage      = "https://github.com/akuzko/rehash"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = '>= 2.1.0'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-nav"
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: re-hash
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Artem Kuzko
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-03-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Easy-to-use hash deeply nested values mapping and transformation.
+email:
+- a.kuzko@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/rehash.rb
+- lib/rehash/hash_extension.rb
+- lib/rehash/mapper.rb
+- lib/rehash/refinement.rb
+- lib/rehash/version.rb
+- rehash.gemspec
+homepage: https://github.com/akuzko/rehash
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Easy-to-use hash values mapping and transformation.
+test_files: []