shrink_wrap 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 44c7258275698404076aaf6de1b39925aad84551
+  data.tar.gz: 057b2f07fae9c2bf5cc8cedfb6e5adf7e2a313c0
+SHA512:
+  metadata.gz: ba4c353fac441540e0218f61137525370b2df55bbca6141564d76398686ee99896c6313f34d0c0c2e71ca26502568b3fff000404ee0642956a8d6f08219e7eac
+  data.tar.gz: baed16d8f899d79c02b3f036b2100b4f3f603785ed97793c6068282c4fd6d426d56539a4aa6ae07e5387d4009f47edb4237554997409943cc05a23c282fdeab0

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/bundle
+Gemfile.lock
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,11 @@
+AllCops:
+  DisplayCopNames: true
+  TargetRubyVersion: 2.5
+  Exclude:
+    - 'bin/**/*'
+    - 'vendor/**/*'
+Documentation:
+  Enabled: false
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'

data/.simplecov

@@ -0,0 +1,3 @@
+SimpleCov.start do
+  SimpleCov.minimum_coverage 100.00
+end

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.16.4

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.1.0 - Dec. 2, 2018
+
+* Initial release! :sparkles:

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at jdoyle@ualberta.ca. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in shrink_wrap.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Jesse Doyle
+
+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,275 @@
+# Shrink::Wrap
+
+## What is Shrink::Wrap?
+
+Shrink::Wrap is a dead-simple framework to manipulate and map JSON data to Ruby object instances.
+
+## Basic Example
+
+Imagine a JSON structure such as:
+
+```json
+{
+  "name": "Milky Way",
+  "age": "13510000000",
+  "solarSystems": [
+    {
+      "name": "Sol",
+      "age": "4571000000",
+      "planets": [
+        {
+          "name": "mercury"
+        },
+        {
+          "name": "venus"
+        },
+        {
+          "name": "earth"
+        }
+      ]
+    }
+  ]
+}
+```
+
+With Shrink::Wrap, you'd be able to map the JSON data to Ruby instances as simply as:
+
+```ruby
+data = JSON.parse(File.read('galaxy.json'))
+Galaxy.shrink_wrap(data) # => #<Galaxy:0x007fec71254828
+ # @age=13510000000,
+ # @name="Milky Way",
+ # @solar_systems=
+ #  [#<SolarSystem:0x007fec71254850
+ #    @age=4571000000,
+ #    @name="Sol",
+ #    @planets=
+ #     [#<Planet:0x007fec712555c0 @name="MERCURY">,
+ #      #<Planet:0x007fec712553e0 @name="VENUS">,
+ #      #<Planet:0x007fec71255200 @name="EARTH">>]>]>
+```
+
+## How Does it Work?
+
+You must include the `Shrink::Wrap` module in your classes to gain access to the `shrink_wrap` method.
+
+For the example above, the implementation would look like:
+
+```ruby
+require 'shrink/wrap'
+
+class Planet
+  include Shrink::Wrap
+
+  transform(Shrink::Wrap::Transformer::Symbolize)
+
+  translate(
+    name: { from: :name }
+  )
+
+  coerce(
+    name: ->(v) { v.upcase }
+  )
+
+  attr_accessor :name
+
+  def initialize(opts = {})
+    self.name = opts.fetch(:name)
+  end
+end
+
+class SolarSystem
+  include Shrink::Wrap
+
+  transform(Shrink::Wrap::Transformer::Symbolize)
+
+  translate(
+    name: { from: :name },
+    age: { from: :age },
+    planets: { from: :planets }
+  )
+
+  coerce(
+    age: ->(v) { v.to_i },
+    planets: Array[Planet]
+  )
+
+  attr_accessor :name, :age, :planets
+
+  def initialize(opts = {})
+    self.name = opts.fetch(:name)
+    self.age = opts.fetch(:age)
+    self.planets = opts.fetch(:planets)
+  end
+end
+
+class Galaxy
+  include Shrink::Wrap
+
+  transform(Shrink::Wrap::Transformer::Symbolize)
+
+  translate(
+    name: { from: :name },
+    age: { from: :age },
+    solar_systems: { from: :solarSystems }
+  )
+
+  coerce(
+    age: ->(v) { v.to_i },
+    solar_systems: Array[SolarSystem]
+  )
+
+  attr_accessor :name, :age, :solar_systems
+
+  def initialize(opts = {})
+    self.name = opts.fetch(:name)
+    self.age = opts.fetch(:age)
+    self.solar_systems = opts.fetch(:solar_systems)
+  end
+end
+```
+
+## Order of Operations
+
+Shrink::Wrap operations are always deterministically performed in the following order:
+
+1. `transform`
+2. `translate`
+3. `coerce`
+
+Shrink::Wrap will call the `initialize` method with the data after all operations have been completed.
+
+## Transform
+
+The `transform` operation accepts a transformation class as well as an options hash as parameters.
+
+The transformation class is any Ruby class that inherits from `Shrink::Wrap::Transformer::Base`.
+
+The class must define a `transform(data = {})` method that returns the data after transformations are applied.
+
+You can chain transformers together by calling `transform` multiple times in your class. Transformers are always executed sequentially.
+
+You can create your own transformer as such:
+
+```ruby
+class FilterEmpty < Shrink::Wrap::Transformer::Base
+  def transform(opts = {})
+    data.each_with_object({}) do |(key, value), memo|
+      memo[key] = value unless value.empty?
+    end
+  end
+end
+```
+
+### Built In Transformers
+
+Shrink::Wrap provides a few built-in transformer classes for use with common transformation patterns.
+
+#### Shrink::Wrap::Transformer::Symbolize
+
+In Ruby, it's very common to convert Hash keys to Symbol instances.
+
+The Symbolize transformer works similar to ActiveSupport's [`deep_symbolize_keys`](https://api.rubyonrails.org/classes/Hash.html#method-i-deep_symbolize_keys) method, but it is also able to traverse nested data structures (`Array`, `Enumerable`) and symbolize the keys of any nested elements as well.
+
+The Symbolize transformer accepts an optional `depth` parameter that defines that maximum depth for symbolization in nested data structures.
+
+Example:
+
+```ruby
+class Example
+  include Shrink::Wrap
+
+  transform(Shrink::Wrap::Transformer::Symbolize, depth: 2)
+  translate_all
+
+  attr_accessor :data
+
+  def initialize(data)
+    self.data = data
+  end
+end
+
+data = { 'root' => [{ 'nested' => 'test' }] }
+instance = Example.shrink_wrap(data)
+instance.data # => {:root=>[{:nested=>"test"}]}
+```
+
+#### Shrink::Wrap::Transformer::CollectionFromKey
+
+Some data Hashes contain keys that contain relevant data for object instances.
+
+The CollectionFromKey transformer accepts a Hash option that contains a key => attribute mapping.
+
+The transformation then creates an Array of elements taken from the key argument and merges the key into each element in the collection.
+
+Example:
+
+```ruby
+class Example
+  include Shrink::Wrap
+
+  transform(Shrink::Wrap::Transformer::CollectionFromKey, weekends: :day)
+  translate_all
+
+  attr_accessor :data
+
+  def initialize(data)
+    self.data = data
+  end
+end
+
+data = {
+  weekends: {
+    saturday: {
+      index: 6
+    },
+    sunday: {
+      index: 0
+    }
+  }
+}
+instance = Example.shrink_wrap(data)
+instance.data # => {:weekends=>[{:index=>6, :day=>:saturday}, {:index=>0, :day=>:sunday}]}
+```
+
+## Translate
+
+The `translate` operation accepts a Hash that contains key/value pairs that map incoming data to attributes.
+
+You can pass the following parameters for each attribute:
+
+* `from` [**required**]: The input key that the attribute is mapped to.
+* `allow_nil` [**optional**]: If `true`, the mapped value may be `nil`. When `false`, raises `KeyError` if the mapped value is `nil`.
+* `default` [**optional**]: A `Proc` or `Lambda` that returns a particular value. This argument will be called if the value is `nil`.
+
+### Passing Data During Initialization
+
+By default, any attributes not specified in a `translate` call are not passed to the underlying object during initialization.
+
+You can call `translate_all` if you wish to pass all of the data but don't wish to explicitly define the attributes in a corresponding `translate` call.
+
+## Coerce
+
+The `coerce` operation accepts a hash of attribute keys and coercion values.
+
+Coercions must be one of the following types:
+
+* `Class`: Tries calling `Class.shrink_wrap(data)`, `Class.coerce(data)`, then `Class.new(data)`, returning the first successful result.
+* `Enumerable`: Coerces the value into the collection of type defined as the Enumerable elements. The first element of the enumerable must be a class name (eg. `Array[MyClass]`, `Hash[MyClass => MyClass]`).
+* `Lambda/Proc`: Coerces the value by calling the `Proc` with the value as the only argument.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jessedoyle/shrink_wrap.
+
+When making code changes please fork the main repository, create a feature branch and then create a pull request with your change. All code changes must contain adequate test coverage.
+
+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.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the ShrinkWrap project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/jessedoyle/shrink_wrap/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: %i[spec rubocop]
+
+RuboCop::RakeTask.new

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'shrink_wrap'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

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/shrink/all.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'pp'
+require_relative 'wrap/version'
+require_relative 'wrap/metadata'
+require_relative 'wrap/support/type_check'
+require_relative 'wrap/property/translation'
+require_relative 'wrap/property/coercion'
+require_relative 'wrap/property/coercion/class'
+require_relative 'wrap/property/coercion/enumerable'
+require_relative 'wrap/property/coercion/proc'
+require_relative 'wrap/transformer/base'
+require_relative 'wrap/transformer/symbolize'
+require_relative 'wrap/transformer/collection_from_key'

data/lib/shrink/wrap/metadata.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Shrink
+  module Wrap
+    class Metadata
+      def add_transformer(klass, opts = {})
+        transformers.push(klass.new(opts))
+      end
+
+      def add_translation(property, opts = {})
+        params = { from: property }.merge(opts)
+        translations[property] = Shrink::Wrap::Property::Translation.new(params)
+      end
+
+      def add_coercion(property, coercion)
+        coercions[property] = Shrink::Wrap::Property::Coercion.new(coercion)
+      end
+
+      def transform(data)
+        transformers.each do |transformer|
+          data = transformer.transform(data)
+        end
+        data
+      end
+
+      def translate(data)
+        return data if translate_all
+
+        translations.each_with_object({}) do |(key, translation), memo|
+          memo[key] = translation.translate(data)
+        end
+      end
+
+      def translate_all!
+        @translate_all = true
+      end
+
+      def coerce(data)
+        data.each_with_object({}) do |(property, value), memo|
+          next if value.nil?
+
+          coercion = coercions[property]
+          memo[property] = coercion&.coerce(value) || value
+        end
+      end
+
+      private
+
+      def translate_all
+        @translate_all ||= false
+      end
+
+      def transformers
+        @transformers ||= []
+      end
+
+      def translations
+        @translations ||= {}
+      end
+
+      def coercions
+        @coercions ||= {}
+      end
+    end
+  end
+end

data/lib/shrink/wrap/property/coercion/class.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Shrink
+  module Wrap
+    module Property
+      class Coercion
+        class Class
+          include Support::TypeCheck
+
+          attr_accessor :klass
+
+          def initialize(klass)
+            ensure_type!(::Class, klass)
+            self.klass = klass
+          end
+
+          def coerce(data)
+            return klass.shrink_wrap(data) if klass.respond_to?(:shrink_wrap)
+            return klass.coerce(data) if klass.respond_to?(:coerce)
+
+            klass.new(data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shrink/wrap/property/coercion/enumerable.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Shrink
+  module Wrap
+    module Property
+      class Coercion
+        class Enumerable
+          include Support::TypeCheck
+
+          attr_accessor :enumerable
+
+          def initialize(enumerable)
+            ensure_type!(::Enumerable, enumerable)
+            self.enumerable = wrap(enumerable.first)
+          end
+
+          def coerce(data)
+            return coerce_hash(data) if enumerable.size > 1
+
+            coerce_enumerable(data)
+          end
+
+          private
+
+          def coerce_hash(data)
+            ensure_type!(Hash, data)
+            key_klass, value_klass = enumerable
+            data.each_with_object({}) do |(key, value), memo|
+              coerced_key = Class.new(key_klass).coerce(key)
+              coerced_value = Class.new(value_klass).coerce(value)
+              memo[coerced_key] = coerced_value
+            end
+          end
+
+          def coerce_enumerable(data)
+            ensure_type!(::Enumerable, data)
+            klass = enumerable.first
+            data.map do |element|
+              Class.new(klass).coerce(element)
+            end
+          end
+
+          def wrap(element)
+            [element].flatten
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shrink/wrap/property/coercion/proc.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Shrink
+  module Wrap
+    module Property
+      class Coercion
+        class Proc
+          include Support::TypeCheck
+
+          attr_accessor :callable
+
+          def initialize(callable)
+            ensure_callable!(callable, 1)
+            self.callable = callable
+          end
+
+          def coerce(data)
+            callable.call(data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shrink/wrap/property/coercion.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Shrink
+  module Wrap
+    module Property
+      class Coercion
+        attr_accessor :base
+
+        def initialize(value)
+          case value
+          when ::Class
+            self.base = Coercion::Class.new(value)
+          when ::Enumerable
+            self.base = Coercion::Enumerable.new(value)
+          when ::Proc
+            self.base = Coercion::Proc.new(value)
+          else
+            fail!(value)
+          end
+        end
+
+        def coerce(data)
+          base.coerce(data)
+        end
+
+        private
+
+        def fail!(value)
+          msg = "expected Class, Enumerable or Proc, got: #{value.inspect}"
+          raise ArgumentError, msg
+        end
+      end
+    end
+  end
+end

data/lib/shrink/wrap/property/translation.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Shrink
+  module Wrap
+    module Property
+      class Translation
+        include Support::TypeCheck
+
+        ATTRIBUTES = %i[
+          allow_nil
+          default
+          from
+        ].freeze
+
+        attr_accessor(*ATTRIBUTES)
+
+        def initialize(opts = {})
+          self.allow_nil = opts.fetch(:allow_nil) { false }
+          self.default = opts[:default]
+          self.from = opts.fetch(:from)
+        end
+
+        def translate(opts = {})
+          ensure_type!(Hash, opts)
+          translate_single(opts)
+        end
+
+        private
+
+        def translate_single(opts)
+          return opts[from] if allow_nil
+          return opts.fetch(from) { key_error!(opts) } if default.nil?
+
+          ensure_callable!(default, 0)
+          opts.fetch(from) { default.call }
+        end
+
+        def key_error!(opts)
+          pretty_hash = StringIO.new
+          PP.pp(opts, pretty_hash)
+          raise KeyError, <<~MSG
+            Key not found `#{from.inspect}`
+            Searching:
+            #{pretty_hash.string}
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/shrink/wrap/support/type_check.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Shrink
+  module Wrap
+    module Support
+      module TypeCheck
+        # rubocop:disable Style/GuardClause
+        def ensure_type!(klass, data)
+          unless data.is_a?(klass)
+            raise ArgumentError, "expected #{klass}, got: #{data.inspect}"
+          end
+        end
+
+        def ensure_callable!(element, arity = nil)
+          unless element.respond_to?(:call)
+            raise ArgumentError, "expected callable, got: #{element.inspect}"
+          end
+
+          if arity && (!element.respond_to?(:arity) || element.arity != arity)
+            raise ArgumentError, "expected callable with arity of #{arity}"
+          end
+        end
+        # rubocop:enable Style/GuardClause
+      end
+    end
+  end
+end

data/lib/shrink/wrap/transformer/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Shrink
+  module Wrap
+    module Transformer
+      class Base
+        ATTRIBUTES = %i[
+          options
+        ].freeze
+
+        attr_accessor(*ATTRIBUTES)
+
+        def initialize(opts = {})
+          self.options = opts
+        end
+
+        def transform(_input)
+          raise NotImplementedError, 'must define #transform in a subclass'
+        end
+      end
+    end
+  end
+end

data/lib/shrink/wrap/transformer/collection_from_key.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Shrink
+  module Wrap
+    module Transformer
+      class CollectionFromKey < Base
+        include Support::TypeCheck
+
+        def initialize(opts = {})
+          unless valid_options?(opts)
+            raise ArgumentError, 'options must contain one key/value pair'
+          end
+
+          super
+        end
+
+        def transform(input)
+          ensure_type!(Hash, input)
+          from, to = options.first
+          data = input[from]
+          return input unless data.is_a?(Hash)
+
+          mapped = map(data, to)
+          input.merge(from => mapped)
+        end
+
+        private
+
+        def map(data, to)
+          data.map do |key, value|
+            ensure_type!(Hash, value)
+            value.merge(to => key)
+          end
+        end
+
+        def valid_options?(opts)
+          opts.is_a?(Hash) && opts.size == 1
+        end
+      end
+    end
+  end
+end

data/lib/shrink/wrap/transformer/symbolize.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Shrink
+  module Wrap
+    module Transformer
+      class Symbolize < Base
+        DEFAULT_DEPTH = 1
+
+        def transform(input)
+          symbolize(input, 0)
+        end
+
+        private
+
+        def symbolize(element, depth, symbolize_singular = false)
+          return element if depth > options.fetch(:depth) { DEFAULT_DEPTH }
+
+          case element
+          when Hash
+            symbolize_hash(element, depth + 1)
+          when Enumerable
+            symbolize_enumerable(element, depth)
+          else
+            symbolize_singular ? to_sym(element) : element
+          end
+        end
+
+        def symbolize_enumerable(array, depth)
+          array.map { |i| symbolize(i, depth) }
+        end
+
+        def symbolize_hash(hash, next_depth)
+          hash.each_with_object({}) do |(key, value), memo|
+            new_key = symbolize(key, next_depth, true)
+            new_value = symbolize(value, next_depth, false)
+            memo[new_key] = new_value
+          end
+        end
+
+        def to_sym(element)
+          element.respond_to?(:to_sym) ? element.to_sym : element
+        end
+      end
+    end
+  end
+end

data/lib/shrink/wrap/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Shrink
+  module Wrap
+    VERSION = '0.1.0'
+  end
+end

data/lib/shrink/wrap.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'all'
+
+module Shrink
+  module Wrap
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def transform(klass, opts = {})
+        metadata.add_transformer(klass, opts)
+      end
+
+      def translate(opts = {})
+        opts.each do |key, value|
+          metadata.add_translation(key, value)
+        end
+      end
+
+      def translate_all
+        metadata.translate_all!
+      end
+
+      def coerce(opts = {})
+        opts.each do |key, value|
+          metadata.add_coercion(key, value)
+        end
+      end
+
+      def shrink_wrap(data)
+        transformed = metadata.transform(data)
+        translated = metadata.translate(transformed)
+        coerced = metadata.coerce(translated)
+        new(coerced)
+      end
+
+      private
+
+      def metadata
+        @metadata ||= Metadata.new
+      end
+    end
+  end
+end

data/lib/shrink_wrap.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'shink/wrap'

data/shrink_wrap.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shrink/wrap/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'shrink_wrap'
+  spec.version = Shrink::Wrap::VERSION
+  spec.authors = ['Jesse Doyle']
+  spec.email = ['jdoyle@ualberta.ca']
+  spec.summary = 'Transform complex JSON data into custom Ruby objects'
+  spec.description = 'Shrink::Wrap is a dead-simple framework to manipulate' \
+                     ' and map JSON data to Ruby object instances.'
+  spec.homepage = 'https://github.com/jessedoyle/shrink_wrap'
+  spec.license = 'MIT'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`
+      .split("\x0")
+      .reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'simplecov'
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: shrink_wrap
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jesse Doyle
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-12-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !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: '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: rubocop
+  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: simplecov
+  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: Shrink::Wrap is a dead-simple framework to manipulate and map JSON data
+  to Ruby object instances.
+email:
+- jdoyle@ualberta.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".simplecov"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/shrink/all.rb
+- lib/shrink/wrap.rb
+- lib/shrink/wrap/metadata.rb
+- lib/shrink/wrap/property/coercion.rb
+- lib/shrink/wrap/property/coercion/class.rb
+- lib/shrink/wrap/property/coercion/enumerable.rb
+- lib/shrink/wrap/property/coercion/proc.rb
+- lib/shrink/wrap/property/translation.rb
+- lib/shrink/wrap/support/type_check.rb
+- lib/shrink/wrap/transformer/base.rb
+- lib/shrink/wrap/transformer/collection_from_key.rb
+- lib/shrink/wrap/transformer/symbolize.rb
+- lib/shrink/wrap/version.rb
+- lib/shrink_wrap.rb
+- shrink_wrap.gemspec
+homepage: https://github.com/jessedoyle/shrink_wrap
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Transform complex JSON data into custom Ruby objects
+test_files: []