hash19 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f6e2781c60e26a68ec9744c3fae4425ae8eaeab4
+  data.tar.gz: 43f215b409572f8598d85448050a1256557253d6
+SHA512:
+  metadata.gz: 86e5288025699960a6fa93425a8e62046148af170a9ae718af00e6777694d91b0de7ee68cb8d9490dd8e2bf5a9a9d01d68e387e5e091641636d381cf232e17e5
+  data.tar.gz: bd08b6977bbdb47f2b3a7a4e1332095aba92673b2e21f59f5a01921cb936f4a810434d7f2a199338c32d83a06e31dfad57d78016e04775937ed455cb3034d602

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea

data/.ruby-gemset

@@ -0,0 +1 @@
+hash19

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.3

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - ruby-2.1.1
+  - ruby-2.1.2
+  - ruby-2.1.3

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 RC
+
+MIT License
+
+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,33 @@
+# Hash19
+
+[![Build Status](https://travis-ci.org/rcdexta/hash19.svg)](https://travis-ci.org/rcdexta/hash19)
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hash19'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hash19
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/hash19/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/Rakefile

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

data/hash19.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hash19/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'hash19'
+  spec.version       = Hash19::VERSION
+  spec.authors       = ['RC']
+  spec.email         = ['rc.chandru@gmail.com']
+  spec.summary       = %q{Hash helpers to map complex JSON to ruby objects}
+  spec.description   = %q{Handles associations and eager loading and collection injection }
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'activesupport'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake'
+
+  spec.add_runtime_dependency 'jsonpath', '~> 0.5.6'
+  spec.add_runtime_dependency 'eldritch'
+
+end

data/lib/hash19/core.rb

@@ -0,0 +1,59 @@
+module Hash19
+  module Core
+
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      include Hash19::CoreHelpers
+    end
+
+    include Hash19::Resolvers
+
+    module Initializer
+      def initialize(payload={})
+        if self.class.contains_klass
+          @hash19 = payload.map do |el|
+            klass = resolve_class(self.class.contains_klass.to_s.camelize.singularize)
+            klass.send(:new, el).to_h(lazy: true)
+          end
+        else
+          hash = payload.with_indifferent_access
+          @hash19 = hash.slice(*self.class.keys)
+          resolve_aliases if self.class.aliases.present?
+          resolve_has_one(hash) if self.class.one_assocs.present?
+          resolve_has_many(hash) if self.class.many_assocs.present?
+        end
+        resolve_injections(@hash19) if self.class.injections.present?
+      end
+    end
+
+    def self.included(klass)
+      klass.send :prepend, Initializer
+    end
+
+    def to_h(lazy:false)
+      return @hash19 if lazy
+      if @hash19.is_a? Array
+        @hash19.map { |hash| traverse_hash(hash) }
+      else
+        traverse_hash(@hash19)
+      end
+    end
+
+    private
+    def traverse_hash(hash)
+      hash.each_with_object({}) do |(k,v),res|
+        res[k] = if v.is_a?(LazyValue)
+                   v.value
+                 elsif v.is_a?(Hash19)
+                   v.to_h
+                 elsif v.is_a?(Hash)
+                   traverse_hash(v)
+                 else
+                   v
+                 end
+      end.with_indifferent_access
+    end
+
+  end
+end

data/lib/hash19/core_helpers.rb

@@ -0,0 +1,47 @@
+module Hash19
+  module CoreHelpers
+
+    attr_accessor :keys
+    attr_accessor :aliases
+    attr_accessor :one_assocs
+    attr_accessor :many_assocs
+    attr_accessor :injections
+    attr_accessor :contains_klass
+
+    def attributes(*list)
+      add_attributes(*list)
+    end
+
+    def attribute(name, opts = {})
+      add_attributes(opts[:key] || name)
+      @aliases ||= {}
+      @aliases[opts[:key]] = name if opts.has_key?(:key)
+    end
+
+    def has_one(name, opts = {})
+      @one_assocs ||= {}
+      @one_assocs[name] = opts
+    end
+
+    def has_many(name, opts = {})
+      @many_assocs ||= {}
+      @many_assocs[name] = opts
+    end
+
+    def inject(opts)
+      @injections ||= []
+      @injections << opts
+    end
+
+    def contains(class_name)
+      @contains_klass = class_name
+    end
+
+    private
+
+    def add_attributes(*list)
+      @keys ||= []
+      @keys += list
+    end
+  end
+end

data/lib/hash19/lazy_value.rb

@@ -0,0 +1,11 @@
+module Hash19
+  class LazyValue
+    def initialize(callable)
+      @block = callable
+    end
+
+    def value
+      @block.call
+    end
+  end
+end

data/lib/hash19/resolvers.rb

@@ -0,0 +1,64 @@
+module Hash19
+  module Resolvers
+
+    def resolve_has_one(hash)
+      resolve_associations(hash, self.class.one_assocs, :one)
+    end
+
+    def resolve_has_many(hash)
+      resolve_associations(hash, self.class.many_assocs, :many)
+    end
+
+    def resolve_associations(hash, associations, type)
+      associations.each do |name, opts|
+        class_name = name.to_s.camelize
+        association = hash[opts[:key] || name]
+        if association.present?
+          klass = resolve_class(class_name.singularize)
+          @hash19[opts[:alias] || name] = if type == :one
+                                            klass.send(:new, association).to_h(lazy: true)
+                                          elsif type == :many
+                                            association.map { |hash| klass.send(:new, hash).to_h(lazy: true) }
+                                          end
+        else
+          # raise "Key:<#{name}> is not present in #{self.class.name}. Possible specify a trigger" unless
+          @hash19[opts[:alias] || name] = LazyValue.new(-> { opts[:trigger].call(@hash19.delete(opts[:using])) }) if opts[:trigger]
+        end
+      end
+    end
+
+    def resolve_aliases
+      self.class.aliases.each do |key, as|
+        @hash19[as] = @hash19.delete(key) if @hash19.has_key?(key)
+      end
+    end
+
+    def resolve_injections(hash)
+      together do
+        self.class.injections.each do |opts|
+          async do
+            entries = JsonPath.new(opts[:at]).on(hash).flatten
+            ids = entries.map { |el| el[opts[:using]] }
+            to_inject = opts[:trigger].call(ids).map(&:with_indifferent_access)
+            key = opts[:as] || opts[:using].to_s.gsub(/_id$|Id$/, '')
+            entries.each do |entry|
+              id = entry.delete(opts[:using])
+              target = to_inject.find { |el| el[opts[:reference] || opts[:using]] == id }
+              entry[key] = target
+            end
+          end
+        end
+      end
+    end
+
+
+    def resolve_class(assoc_name)
+      full_class_name = self.class.name
+      new_class = full_class_name.gsub(full_class_name.demodulize, assoc_name)
+      new_class.split('::').inject(Object) do |mod, class_name|
+        mod.const_get(class_name)
+      end
+    end
+
+  end
+end

data/lib/hash19/version.rb

@@ -0,0 +1,3 @@
+module Hash19
+  VERSION = '0.0.1'
+end

data/lib/hash19.rb

@@ -0,0 +1,13 @@
+require 'hash19/version'
+require 'hash19/lazy_value'
+require 'hash19/core_helpers'
+require 'hash19/resolvers'
+require 'hash19/core'
+require 'active_support/all'
+require 'jsonpath'
+require 'eldritch'
+
+module Hash19
+  extend ActiveSupport::Concern
+  include Core
+end

data/spec/hash19/associations_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe 'Associations' do
+
+  class Testable
+    include Hash19
+  end
+
+  context 'has_one associations' do
+    class Child < Testable
+      attributes :x, :y, :z
+    end
+
+    class Parent < Testable
+      attributes :p, :q
+      has_one :child
+    end
+
+    it 'should be able to load the has_one child associations' do
+      parent = Parent.new(p: 1, q: 2, child: {x: 1, p: 3})
+      expect(parent.to_h).to eq('p' => 1, 'q' => 2, 'child' => {'x' => 1})
+    end
+
+    it 'should support key for has_one' do
+      class OtherParent < Testable
+        attributes :x
+        has_one :child, key: :offspring, class: 'Child'
+      end
+
+      parent = OtherParent.new(x: true, offspring: {x: 1, p: 3})
+      expect(parent.to_h).to eq('x' => true, 'child' => {'x' => 1})
+    end
+
+    it 'should support alias for has_one' do
+      class AnotherParent < Testable
+        attributes :x
+        has_one :child, key: :offspring, alias: :junior
+      end
+
+      parent = AnotherParent.new(x: true, offspring: {x: 1, p: 3})
+      expect(parent.to_h).to eq('x' => true, 'junior' => {'x' => 1})
+    end
+  end
+
+  context 'has_many associations' do
+    class Wheel < Testable
+      attributes :flat
+    end
+
+    class Bike < Testable
+      attributes :cc
+      has_many :wheels
+    end
+
+    it 'should be able to load the has_one child associations' do
+      bike = Bike.new(cc: 150, wheels: [{name: 'one', flat: false}, {name: 'two', flat: true}])
+      expect(bike.to_h).to eq('cc' => 150, 'wheels' => [{'flat' => false}, {'flat' => true}])
+    end
+
+    it 'should support key for has_many' do
+      class OtherBike < Testable
+        attributes :cc
+        has_many :wheels, key: :discs
+      end
+
+      bike = OtherBike.new(cc: 150, discs: [{name: 'one', flat: false}, {name: 'two', flat: true}])
+      expect(bike.to_h).to eq('cc' => 150, 'wheels' => [{'flat' => false}, {'flat' => true}])
+    end
+
+    it 'should support alias for has_many' do
+      class AnotherBike < Testable
+        attributes :cc
+        has_many :wheels, key: :discs, alias: :rings
+      end
+
+      bike = AnotherBike.new(cc: 150, discs: [{name: 'one', flat: false}, {name: 'two', flat: true}])
+      expect(bike.to_h).to eq('cc' => 150, 'rings' => [{'flat' => false}, {'flat' => true}])
+    end
+  end
+
+  context 'across modules' do
+    module Bird
+      class Duck < Testable
+        attribute :quack
+        has_many :feathers
+      end
+
+      class Feather < Testable
+        attribute :light
+      end
+    end
+
+    it 'should be able to resolve has_many relationship within modules' do
+      duck = Bird::Duck.new(quack: true, feathers: [{light: true}, {light: true}])
+      expect(duck.to_h).to eq('quack' => true, 'feathers' => [{'light' => true}, {'light' => true}])
+    end
+  end
+
+  class Error < Testable
+    attributes :error_id, :desc
+
+    def self.find(id)
+      {error_id: 500, desc: 'fatal error'}
+    end
+
+    def self.find_all
+      [{error_id: 500, desc: 'fatal error'}, {error_id: 404, desc: 'not found'}]
+    end
+  end
+
+  context 'has_one evaluation' do
+
+    class Packet < Testable
+      attributes :code, :error_id
+      has_one :error, using: :error_id, trigger: ->(id) { Error.find id }
+    end
+
+    it 'should be able to call the trigger on has_one association' do
+      packet = Packet.new(code: 500, error_id: 500)
+      expect(packet.to_h).to eq('code' => 500, 'error_id' => 500, 'error' => {'error_id' => 500, 'desc' => 'fatal error'})
+    end
+
+  end
+
+  context 'has_many evaluation' do
+
+    class UDPPacket < Testable
+      attributes :code, :error_id
+      has_many :errors, using: :error_id, trigger: ->(id) { Error.find_all }, alias: 'all_errors'
+    end
+
+    it 'should be able to call the trigger on has_one association' do
+      packet = UDPPacket.new(code: 500, error_id: 500)
+      expect(packet.to_h).to eq('code' => 500, 'error_id' => 500, 'all_errors' => [{'error_id' => 500, 'desc' => 'fatal error'},
+                                                                           {'error_id' => 404, 'desc' => 'not found'}])
+    end
+
+  end
+
+
+end

data/spec/hash19/contains_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe 'Containers' do
+
+  class Testable
+    include Hash19
+  end
+
+  class SuperHeroes < Testable
+    contains :super_heroes
+    inject at: '$', using: :weapon_id, reference: :id, trigger: lambda { |ids| Weapon.find_all ids }
+  end
+
+  class SuperHero < Testable
+    attributes :name, :power, :weapon_id
+    has_one :weapon, using: :weapon_id, trigger: lambda { |id| Weapon.find id }
+  end
+
+  class Weapon < Testable
+    attributes :name, :id
+
+    def self.find_all(ids)
+      [{'name' => 'jarvis', 'id' => 1},
+       {'name' => 'hammer', 'id' => 2},
+       {'name' => 'hands', 'id' => 3}]
+    end
+  end
+
+  context 'contains directive' do
+    it 'should comprise of collection of specified object' do
+      super_heroes = SuperHeroes.new([{name: 'iron man', power: 'none', weapon_id: 1},
+                                      {name: 'thor', power: 'class 100', weapon_id: 2},
+                                      {name: 'hulk', power: 'bulk', weapon_id: 3}])
+
+      expect(super_heroes.to_h).to eq([{'name' => 'iron man', 'power' => 'none', 'weapon' => {'name' => 'jarvis', 'id' => 1}},
+                                       {'name' => 'thor', 'power' => 'class 100', 'weapon' => {'name' => 'hammer', 'id' => 2}},
+                                       {'name' => 'hulk', 'power' => 'bulk', 'weapon' => {'name' => 'hands', 'id' => 3}}])
+    end
+
+  end
+end

data/spec/hash19/core_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Hash19::Core do
+
+  class Testable
+    include Hash19
+  end
+
+  context 'declare attributes' do
+
+    class Test1 < Testable
+      attributes :a, :b, :c
+    end
+
+
+    it 'should be able to assign whitelisted attributes' do
+      test = Test1.new(a: 1, b: 2, d: 4)
+      expect(test.to_h).to eq('a' => 1, 'b' => 2)
+    end
+
+    it 'should return empty hash when no attributes match' do
+      test = Test1.new(x: 1, y: 2, z: 4)
+      expect(test.to_h).to eq({})
+    end
+
+  end
+
+  context 'Single attribute and aliases' do
+
+    class Test2 < Testable
+      attributes :a, :b, :c
+      attribute :fake, key: :actual
+      attribute :d
+    end
+
+    it 'should be able to assign attributes based on alias' do
+      test = Test2.new(actual: 1)
+      expect(test.to_h).to eq('fake' => 1)
+    end
+
+    it 'should be able to use both attribute and attributes constructs' do
+      test = Test2.new(actual: 1, a: 2, d: 3)
+      expect(test.to_h).to eq('fake' => 1, 'a' => 2, 'd' => 3)
+    end
+
+    it 'should ignore alias if key not present' do
+      test = Test2.new(a: 2)
+      expect(test.to_h).to eq('a' => 2)
+    end
+  end
+
+
+
+end

data/spec/hash19/future_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Hash19::LazyValue do
+
+  class Sheep
+    attr_accessor :name
+    def shout
+      "My name is #{@name || 'black sheep'}"
+    end
+  end
+
+  it 'should be able to postpone execution of a block' do
+    sheep = Sheep.new
+    delayed_voice = Hash19::LazyValue.new(-> { sheep.shout })
+    sheep.name = 'Dolly'
+    expect(delayed_voice.value).to eq('My name is Dolly')
+  end
+end

data/spec/hash19/injection_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe 'Injections' do
+
+  class Testable
+    include Hash19
+  end
+
+  context 'has_many injection' do
+
+    class SuperVillain < Testable
+      attribute :name
+      has_many :minions
+      inject at: '$.minions', using: :fruit_id, reference: :id, trigger: lambda { |ids| Fruit.find_all ids }, as: 'eats'
+    end
+
+    class Minion < Testable
+      attributes :name, :fruit_id
+    end
+
+    class Fruit < Testable
+      attributes :id, :name
+
+      def self.find_all(ids)
+        [{id: 1, name: 'banana'}, {id: 2, name: 'apple'}, {id: 3, name: 'orange'}]
+      end
+    end
+
+
+    it 'should be able to extract ids from a has_many association and inject' do
+      gru_team = SuperVillain.new(name: 'Gru', minions: [{name: 'Poppadom', fruit_id: 1},
+                                                         {name: 'Gelato', fruit_id: 2},
+                                                         {name: 'Kanpai', fruit_id: 3}])
+      expect(gru_team.to_h).to eq('name' => 'Gru', 'minions' => [{'name' => 'Poppadom', 'eats' => {'id' => 1, 'name' => 'banana'}},
+                                                                 {'name' => 'Gelato', 'eats' => {'id' => 2, 'name' => 'apple'}},
+                                                                 {'name' => 'Kanpai', 'eats' => {'id' => 3, 'name' => 'orange'}}
+                                                 ])
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'active_support/all'
+require 'pry'
+require 'hash19'
+

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: hash19
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- RC
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: activesupport
+  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: rspec
+  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
+  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: rake
+  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: jsonpath
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6
+- !ruby/object:Gem::Dependency
+  name: eldritch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'Handles associations and eager loading and collection injection '
+email:
+- rc.chandru@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hash19.gemspec
+- lib/hash19.rb
+- lib/hash19/core.rb
+- lib/hash19/core_helpers.rb
+- lib/hash19/lazy_value.rb
+- lib/hash19/resolvers.rb
+- lib/hash19/version.rb
+- spec/hash19/associations_spec.rb
+- spec/hash19/contains_spec.rb
+- spec/hash19/core_spec.rb
+- spec/hash19/future_spec.rb
+- spec/hash19/injection_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Hash helpers to map complex JSON to ruby objects
+test_files:
+- spec/hash19/associations_spec.rb
+- spec/hash19/contains_spec.rb
+- spec/hash19/core_spec.rb
+- spec/hash19/future_spec.rb
+- spec/hash19/injection_spec.rb
+- spec/spec_helper.rb