htransform 0.8.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/README.md

@@ -0,0 +1,149 @@
+HTransform
+======
+
+HTransform provides a simple DSL to transform a supplied hash with an arbitrary structure to another hash with an even more arbitrary structure.
+
+***Note:*** *HTransform does not simply modify the hash you have passed in. It actually creates a new hash from scratch. It only copies or does transformations on the fields you specify in the transform block.*
+
+Support
+=======
+
+Should work for both 1.8 and 1.9 rubies.
+
+Install
+=======
+
+Standard gem install.
+
+        gem install htransform
+
+
+Put this in your Gemfile.
+
+        gem "htransform"
+
+or
+
+        gem "htransform", :git =>
+          "git://github.com/joshkrueger/htransform.git"
+
+Basic Usage
+===========
+
+All you have to do is create a new class and inherit from HTransform.
+
+        class ExampleHTransform < HTransform
+        end
+
+Inside your new class you just use the hopefully not-convoluted DSL.
+
+        class ExampleHTransform < HTransform
+          transform do
+            input :from => "foo", :to => :bar
+          end
+        end
+
+Theres also shorthand for you lazy folks.
+
+        input "foo" => :bar
+        
+But how do I do more than just re-name my keys?
+
+Let's start simple. Lets take the following hash
+
+        { "foo" => "party" }
+
+and have HTransform change it to
+
+        { :foo => "Party" }
+
+Its pretty easy!
+
+        input "foo" => :foo, :via => :capitalize
+
+See! Nice and simple!
+
+HTransform with a block!
+
+        input "foo" => :foo, :via => lambda { |x| x.capitalize }
+
+Actually Using HTransform
+================
+
+So we have our ExampleHTransform we created above (with our capitalize transform), saved somewhere. Lets say its in your "lib" folder. Anywhere it's loadable via require should be fine.
+
+        require 'htransform'
+        require 'example_htransform'
+
+        contrived_input_hash = { "foo" => "bar" }
+
+        output_hash = ExampleHTransform.convert(contrived_input_hash)
+
+and now output_hash should look like
+
+        { :foo => "Bar" }
+
+Slightly Less Basic Usage
+=================
+
+Want to combine multiple input keys? **HTransform CAN DO THAT**
+        
+        input_multiple ["foo", "bar"] => :foo_bar
+
+By default HTransform will just join the multiple elements with a space. i.e. "foo" and "bar" become "foo bar". Need something more complicated?
+
+        input_multiple ["foo", "bar"] => :foo_bar, :via => lambda { |x| x.map{ |v| v.capitalize }.join(" ") }
+
+Here, "foo" and "bar" become "Foo Bar". Easy right?
+
+Hrmm. What about nested hashes? No problem. Just define the nesting order in an array.
+
+Lets start with nested inputs. Given the hash
+
+        { "foo" => { "bar" => "sample text" } }
+
+and a desired hash of
+
+        {  "example" => "sample text" }
+
+we would give HTransform the following operation
+
+        input ["foo", "bar"] => "example"
+
+If we want the opposite, all we do is reverse it.
+
+        input "example" => ["foo", "bar"]
+
+Nested to nested?
+
+        input ["foo", "bar"] => ["baz", "qux"]
+
+this turns
+
+        { "foo" => { "bar" => "hello world" } }
+
+into
+
+        { "baz" => { "qux" => "hello world" } }
+
+Want to combine multiple inputs when one or more are an array?
+
+        input [ [ "foo", "bar" ], "baz" ] => "combined nested hash"
+
+Shorthand Limitations
+==============
+
+Hey, the shorthand isn't perfect and theres really only a couple scenarios I can think of. If you have a key on your input hash of :via, you can't use the shorthand.
+
+        input :via => :not_via
+
+That won't work. Why? **I'm lazy** So just use the long format.
+
+        input :from => :via, :to => :not_via, :via => :capitalize
+
+However, :from or :to will work just fine in the shorthand. The longhand syntax only works if both the :from and :to symbols are passed in.
+
+        input :from => "from"
+
+That will work.
+

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+require "rspec"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w(--format documentation --color)
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :default => ["spec"]

data/examples/example.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/ruby
+
+require 'htransform'
+require 'example_transform'
+
+in_hash = {
+  "fname" => "JOHN",
+  "lname" => "doe",
+  "phonenum" => "555-123-1122",
+  "email" => "j.doe@example.com",
+  "state_id" => {
+    "number" => "d123456",
+    "state" => "il",  
+    "type" => "drivers"
+  }
+}
+
+desired_hash = {
+  :first_name => "John",
+  :last_name => "Doe",
+  :full_name => "John Doe",
+  :contact_info => {
+    :phone_number => "5551231122",
+    :email_address => "j.doe@example.com"
+  },
+  :state_identification => {
+    :issuing_state => "IL",
+    :type => "drivers",
+    :number => "D123456"
+  }
+}
+
+result_hash = ExampleTransform.convert(in_hash)
+
+puts "The Hash Transformation worked correctly!" if result_hash == desired_hash

data/examples/example_htransform.rb

@@ -0,0 +1,18 @@
+require 'htransform'
+
+class ExampleTransform < HTransform
+  transform do
+
+    input "fname" => :first_name, :via => :capitalize
+    input :from => "lname", :to => :last_name, :via => lambda { |x| x.capitalize }
+    input "phonenum" => [:contact_info, :phone_number], :via => lambda { |p| p.gsub("-", "") }
+    input "email" => [:contact_info, :email_address]
+
+    input_multiple :from => ["fname", "lname"], :to => :full_name, :via => lambda { |x| x.map{ |v| v.capitalize }.join(" ") }
+
+    input ["state_id", "state"] => [:state_identification, :issuing_state], :via => :upcase
+    input ["state_id", "number"] => [:state_identification, :number], :via => :upcase
+    input ["state_id", "type"] => [:state_identification, :type]
+
+  end
+end

data/htransform.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "htransform/version"
+
+Gem::Specification.new do |s|
+  s.name        = "htransform"
+  s.version     = HTransform::VERSION
+  s.authors     = ["Josh Krueger"]
+  s.email       = ["joshsinbox@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{HTransform transforms your hashes}
+  s.description = %q{HTransform provides a simple DSL to transform arbitrary hashes into another, more arbitrary hash. Yay.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency("rspec", "~> 2.5.0")
+  s.add_development_dependency("rake")
+end

data/lib/htransform/version.rb

@@ -0,0 +1,3 @@
+class HTransform
+  VERSION = "0.8.0"
+end

data/lib/htransform.rb

@@ -0,0 +1,198 @@
+require "htransform/version"
+
+class HTransform
+
+  ValueNotPresentError = Class.new(StandardError)
+
+  class << self
+    attr_reader :transform_block
+
+    attr_reader :input_nest
+    attr_reader :output_nest
+
+    def convert(input_hash)
+      new.convert(input_hash)
+    end
+
+    def transform(&trans_block)
+      @transform_block = trans_block
+    end
+
+  end
+
+  def initialize
+    @output_hash = Hash.new { |h,k| h[k] = Hash.new(&h.default_proc) }
+    @input_nest = []
+    @output_nest = []
+  end
+
+  def convert(input)
+
+    unless input.is_a? Hash
+      if input.respond_to? :to_hash
+        input = input.to_hash
+      else
+        raise ArgumentError "object is not a Hash or does not respond to to_hash"
+      end
+    end
+
+    @input_hash = input
+    instance_exec(&self.class.transform_block)
+    Hash[@output_hash]
+  end
+
+  private
+
+  def set_val(dst, val)
+
+    dst = (@output_nest + [dst]).flatten unless @output_nest.empty?
+
+    if dst.is_a? Array
+      last_key = dst.pop
+      dst.reduce(@output_hash) { |h,k| h[k] }[last_key] = val
+    else
+      @output_hash[dst] = val
+    end
+  end
+
+  def get_val(src)
+    return get_val!(src)
+  rescue ValueNotPresentError
+    return nil
+  end
+
+  def get_val!(src)
+
+    src = (@input_nest + [src]).flatten unless @input_nest.empty?
+
+    if src.is_a? Array
+      src.reduce(@input_hash) { |h,k| h[k] }
+    else
+      if @input_hash.key?(src)
+        @input_hash[src]
+      else
+        raise ValueNotPresentError
+      end
+    end
+  end
+
+  def key_present?(src)
+    src = (@input_nest + [src]).flatten unless @input_nest.empty?
+    if src.is_a? Array
+      src.reduce(@input_hash) do |h, k|
+        h[k].is_a?(Hash) ? h[k] : h.has_key?(k)
+      end
+    else
+      @input_hash.key?(src)
+    end
+  end
+
+  def parse_options(options)
+    from, to, via, default = nil
+
+    via = options.delete :via
+    default = options.delete :default
+
+    from, to = if options.key? :from and options.key? :to
+      [options[:from], options[:to]]
+    else
+      options.delete :from
+      options.delete :to
+
+      lazy_args = options.shift
+      if lazy_args.is_a? Array and lazy_args.length == 2
+        lazy_args
+      end
+    end
+
+    [from, to, via, default]
+  end
+
+  def passthrough(*options)
+    options.each do |k|
+      begin
+        input_value = get_val!(k)
+        set_val(k, input_value)
+      rescue ValueNotPresentError
+      end
+    end
+  end
+
+  def input_multiple(options)
+    from, to, via, default = parse_options(options)
+    via = lambda { |x| x.join(" ") } if via.nil?
+
+
+    old_values = from.map{ |k| get_val(k) }
+    new_value = if via.is_a? Proc
+      via.call old_values
+    elsif via.is_a? Symbol
+      if methods.include? via.to_s or methods.include? via
+        via_method = method(via)
+        if via_method.arity != 1
+          via_method.call(*old_values)
+        else
+          via_method.call(old_values)
+        end
+      else
+        old_values.send(via)
+      end
+    end
+
+
+    set_val(to, new_value)
+  end
+
+  def input(options)
+    from, to, via, default = parse_options(options)
+    return if !key_present?(from) && default.nil?
+
+    new_value = if get_val(from).nil? && !default.nil?
+      default.respond_to?(:call) ? default.call : default
+    elsif via.is_a? Proc
+      via.call get_val(from)
+    elsif via.is_a? Symbol
+      if methods.include? via.to_s or methods.include? via
+        via_method = method(via)
+        if via_method.arity != 1
+          method(via).call(*get_val(from))
+        else
+          method(via).call(get_val(from))
+        end
+      else
+        get_val(from).send(via)
+      end
+    else
+      get_val(from)
+    end
+
+    set_val(to, new_value)
+  end
+
+  def insert(options)
+    options.each { |key, value| set_val(key, value) }
+  end
+
+  def nested(options,  &trans_block)
+    
+    if options.is_a? Symbol
+      options = {:key => options, :type => "output"}
+    else
+      options[:type] = "output" unless options.key? :type
+    end
+
+    if options[:type] == "output" or options[:type] == "input"
+      type = options[:type]
+      if options[:key]
+        key = options[:key]
+        nest_var = "@#{type}_nest"
+        self.instance_variable_set(:"#{nest_var}", self.instance_variable_get(:"#{nest_var}") + [key].flatten)
+
+        instance_exec(&trans_block)
+
+        self.instance_variable_set(:"#{nest_var}", self.instance_variable_get(:"#{nest_var}") - [key].flatten)
+      end
+    end
+  end
+
+end

data/spec/htransform_nested_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+require 'date'
+
+describe HTransform do
+  describe "convert" do
+    context "using the nested block" do
+
+      it "defaults to output nesting" do
+        class TestHTransform < HTransform
+          transform do
+            nested :key => :foo_nest do
+              input "foo" => :foo
+            end
+          end
+        end
+
+        input_hash = { "foo" => "bar" }
+        desired_hash = { :foo_nest => { :foo => "bar" } }
+
+        result = TestHTransform.convert(input_hash)
+
+        result.should == desired_hash        
+      end
+
+      it "uses output nested when specified" do
+        class TestHTransform < HTransform
+          transform do
+            nested :type => "output", :key => :foo_nest do
+              input "foo" => :foo
+            end
+          end
+        end
+
+        input_hash = { "foo" => "bar" }
+        desired_hash = { :foo_nest => { :foo => "bar" } }
+        
+        result = TestHTransform.convert(input_hash)
+        
+        result.should == desired_hash
+      end
+
+      it "uses input nesting when specified" do
+        class TestHTransform < HTransform
+          transform do
+            nested :type => "input", :key => :nested_data do
+              input "foo" => :foo
+            end
+          end
+        end
+
+        input_hash = { :nested_data => { "foo" => "bar" } }
+        desired_hash = { :foo => "bar" }
+        
+        result = TestHTransform.convert(input_hash)
+        
+        result.should == desired_hash
+      end
+
+      it "can nest multiple nested blocks of different types" do
+        class TestHTransform < HTransform
+          transform do
+            nested :type => "input", :key => :nested_input do
+              input :foo_nest => :foo
+              input :bar_nest => :bar
+
+              nested :type => "input", :key => :more_nesting do
+                nested :type => "output", :key => :nested do
+                  input :foobar => :foo_bar
+                end
+              end
+            end
+
+            nested :key => :animal_sounds do
+              passthrough :cat, :dog
+            end
+          end
+        end
+
+        input_hash = { :nested_input => { :foo_nest => "foo!", :bar_nest => "bar!", :more_nesting => { :foobar => "meh"} },
+                        :cat => "meow!", :dog => "woof!" }
+
+        desired_hash = { :foo => "foo!", :bar => "bar!", :nested => { :foo_bar => "meh"} , :animal_sounds => { :cat => "meow!", :dog => "woof!" } }
+        
+        result = TestHTransform.convert(input_hash)
+        
+        result.should == desired_hash
+      end
+
+      it "can use the shorthand method and default to output nesting" do
+        class TestHTransform < HTransform
+          transform do
+            nested :out_nest do
+              input "foo" => :foo
+            end
+          end
+        end
+
+        input_hash = { "foo" => "bar" }
+        desired_hash = { :out_nest => { :foo => "bar" } }
+
+        result = TestHTransform.convert(input_hash)
+
+        result.should == desired_hash
+      end
+
+    end
+  end
+end

data/spec/htransform_spec.rb

@@ -0,0 +1,392 @@
+require 'spec_helper'
+require 'date'
+
+describe HTransform do
+  describe "convert" do
+    it "returns real hashes" do
+      class TestHTransform < HTransform
+        transform do
+          input "foo" => :baz
+        end
+      end
+
+      input_hash = { "foo" => "bar" }
+      result = TestHTransform.convert(input_hash)
+      result[:missing].should be_nil
+    end
+
+    it "can call instance methods from :via" do
+      class TestHTransform < HTransform
+        transform do
+          input "foo" => :foo, :via => lambda { |value| my_method(value) }
+        end
+        def my_method(value); value.reverse; end
+      end
+
+      input_hash = { "foo" => "bar" }
+      TestHTransform.convert(input_hash).should == { :foo => "rab" }
+    end
+
+    context "via is a symbol" do
+      it "can call instance methods via a symbol" do
+        class TestHTransform < HTransform
+        transform do
+          input "foo" => :foo, :via => :single_arg_method
+          input_multiple ["num1", "num2"] => :diff, :via => :multi_arg_method
+          input :nums => :diff2, :via => :multi_arg_method
+          input :nums => :splat_1, :via => :splat_method
+          input "foo" => :foo_splat, :via => :splat_method
+        end
+
+        def single_arg_method(value); value.reverse; end
+        def multi_arg_method(value1, value2); value1 - value2; end
+        def splat_method(*arg); arg.join(", "); end
+      end
+
+      input_hash = { "foo" => "bar", "num1" => 100, "num2" => 50, :nums => [100, 50] }
+
+      desired_hash = {:foo => "rab", :diff => 50, :diff2 => 50, :splat_1 => "100, 50", :foo_splat => "bar" }
+      TestHTransform.convert(input_hash).should == desired_hash
+      end
+    end
+
+    context "the input key is missing" do
+      it "does not set it in the output" do
+        class TestHTransform < HTransform
+          transform do
+            input "birth_date" => :birthday, :via => lambda { |d| d.strftime('%F') }
+          end
+        end
+
+        input_hash = { "foo" => "bar" }
+        TestHTransform.convert(input_hash).should == {}
+      end
+
+      context "the input key is present but the value is nil" do
+        it "does set it in the input" do
+          class TestHTransform < HTransform
+            transform do
+              input "foo" => :bar
+            end
+          end
+
+          input_hash = { "foo" => nil }
+          desired_hash = { :bar => nil }
+
+          TestHTransform.convert(input_hash).should == desired_hash
+        end
+      end
+
+      it "can set a default value" do
+        class TestHTransform < HTransform
+          transform do
+            input "birth_date" => :birthday, :default => Date.today
+            input "death_date" => :deathday, :default => lambda { Date.today + 5 }
+          end
+        end
+
+        input_hash = { "foo" => "bar" }
+        desired_hash = { :birthday => Date.today, :deathday => Date.today + 5 }
+
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+    end
+
+    context "inserting keys" do
+      it "should insert the key regardless of the input hash" do
+        class TestHTransform < HTransform
+          transform do
+            insert :bar => 'bar', :quux => 'quux'
+          end
+        end
+
+        input_hash = { "foo" => "foo" }
+        desired_hash = { :bar => 'bar', :quux => 'quux' }
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+    end
+
+    context "the value has no transform" do
+      it "should produce the same key (string)" do
+        class TestHTransform < HTransform
+          transform do
+            input :from => "foo", :to => "foo"
+          end
+        end
+
+        input_hash = { "foo" => "bar" }
+
+        TestHTransform.convert(input_hash).should == input_hash
+      end
+
+      it "should produce the same key via shorthand (symbol)" do
+        class TestHTransform < HTransform
+          transform do
+            input :foo => :foo
+          end
+        end
+
+        input_hash = { :foo => :bar }
+
+        TestHTransform.convert(input_hash).should == input_hash
+      end
+
+      it "should change the key (string to symbol)" do
+       class TestHTransform < HTransform
+          transform do
+            input "foo" => :foo
+          end
+        end
+
+        input_hash = { "foo" => "bar" }
+        desired_hash = { :foo => "bar" }
+
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+
+      it "should change the key (symbox to key)" do
+        class TestHTransform < HTransform
+          transform do
+            input :foo => "foo"
+          end
+        end
+
+        desired_hash = { "foo" => "bar" }
+        input_hash = { :foo => "bar" }
+
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+
+    end
+
+    context "the value should be capitalized" do
+       it "should produce the same key" do
+        class TestHTransform < HTransform
+          transform do
+            input "foo" => "foo", :via => :capitalize
+          end
+        end
+
+        input_hash = { "foo" => "bar" }
+        desired_hash = { "foo" => "Bar" }
+
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+
+      it "should produce a different key" do
+        class TestHTransform < HTransform
+          transform do
+            input "foo" => :foo, :via => lambda { |x| x.capitalize }
+          end
+        end
+
+        input_hash = { "foo" => "bar" }
+        desired_hash = { :foo => "Bar" }
+
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+
+    end
+
+    context "use nested input" do
+      it "should produce the same key without nesting" do
+        class TestHTransform < HTransform
+          transform do
+            input ["foo", "bar"] => "bar"
+          end
+        end
+
+        input_hash = { "foo" => { "bar" => "FOOBAR!" } }
+        desired_hash = { "bar" => "FOOBAR!" }
+
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+
+      it "should produce a different key without nesting" do
+        class TestHTransform < HTransform
+          transform do
+            input ["foo", "bar"] => :foo_bar
+          end
+        end
+
+        input_hash = { "foo" => { "bar" => "FOOBAR!" } }
+        desired_hash = { :foo_bar => "FOOBAR!" }
+
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+    end
+
+    context "use nested output" do
+      it "should produce the same key, but nested" do
+        class TestHTransform < HTransform
+          transform do
+            input :foo => [:bar, :foo]
+          end
+        end
+
+        input_hash = { :foo => "FOO!" }
+        desired_hash = { :bar => { :foo => "FOO!" } }
+
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+
+      it "should produce a different key, but nested" do
+        class TestHTransform < HTransform
+          transform do
+            input "foo" => [:bar, :foo]
+          end
+        end
+
+        input_hash = { "foo" => "FOO!" }
+        desired_hash = { :bar => { :foo => "FOO!" } }
+
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+
+      it "should produce a different key, but nested (with string keys)" do
+        class TestHTransform < HTransform
+          transform do
+            input "foo" => ["bar", "foo"]
+          end
+        end
+ 
+        input_hash = { "foo" => "FOO!" }
+        desired_hash = { "bar" => { "foo" => "FOO!" } }
+
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+
+      it "should use nested input and produce the same key, but nested differently" do
+        class TestHTransform < HTransform
+          transform do
+            input ["foo", "bar"] => ["baz", "bar"]
+          end
+        end
+
+        input_hash = { "foo" => { "bar" => "BAR!" } }
+        desired_hash = { "baz" => { "bar" => "BAR!" } }
+
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+
+      it "should use nested input and produce a different key, but nested differently" do
+        class TestHTransform < HTransform
+          transform do
+            input ["foo", "bar"] => [:baz, :bar]
+          end
+        end
+
+        input_hash = { "foo" => { "bar" => "BAR!" } }
+        desired_hash = { :baz => { :bar => "BAR!" } }
+
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+    end
+
+    context "use multiple inputs" do
+      it "should join two elements with a space and produce a single key" do
+        class TestHTransform < HTransform
+          transform do
+            input_multiple [:foo, :bar] => :foo_bar
+          end
+        end
+
+        input_hash = { :foo => "Foo", :bar => "Bar" }
+        desired_hash = { :foo_bar => "Foo Bar" }
+
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+
+      it "should join two nested elements with a dash, via a lambda and produce a single key" do
+        class TestHTransform < HTransform
+          transform do
+            input_multiple [[:foo, :bar], [:baz, :qux]] => :bar_qux, :via => lambda { |x| x.join("-") }
+          end
+        end
+
+        input_hash = { :foo => { :bar => "fbar" }, :baz => { :qux => "bqux" } }
+        desired_hash = { :bar_qux => "fbar-bqux" }
+
+        TestHTransform.convert(input_hash).should == desired_hash
+      end
+    end
+
+  end
+
+  context "multiple htransforms" do
+    it "does not share transformations between unrelated subclasses" do
+      class HTransformA < HTransform
+        transform do
+          input "foo" => :foo
+        end
+      end
+
+      class HTransformB < HTransform
+        transform do
+          input "bar" => :bar
+        end
+      end
+
+      input_hash = { "foo" => "fooval", "bar" => "barval" }
+      HTransformA.convert(input_hash).should == { :foo => "fooval" }
+      HTransformB.convert(input_hash).should == { :bar => "barval" }
+    end
+  end
+
+  context "passthrough" do
+
+    it "ignores a passthrough'd key if it is absent" do
+      class TestHTransform < HTransform
+        transform do
+          passthrough :foo
+          input :bar => :bar_key
+        end
+      end
+
+      input_hash = { :bar => 'one' }
+      desired_hash = { :bar_key => 'one' }
+
+      result = TestHTransform.convert(input_hash)
+      result.should == desired_hash
+    end
+
+    it "does not ignore the passthrough key if it is present but nil" do
+      class TestHTransform < HTransform
+        transform do
+          passthrough :foo
+          input :bar => :bar_key
+        end
+      end
+
+      input_hash = { :bar => 'one', :foo => nil }
+      desired_hash = { :bar_key => 'one', :foo => nil }
+
+      result = TestHTransform.convert(input_hash)
+      result.should == desired_hash
+    end
+
+  end
+
+  context "non-hashes" do
+    it "works with objects that respond to to_hash" do
+      class TestHTransform < HTransform
+        transform do
+          passthrough :foo
+          input :bar => :bar_key
+        end
+      end
+
+      class NonHash
+        def to_hash
+          { :foo => "FOO", :bar => 'BAR' }
+        end
+      end
+
+      input_object = NonHash.new
+      desired_hash = { :bar_key => 'BAR', :foo => "FOO" }
+
+      result = TestHTransform.convert(input_object)
+      result.should == desired_hash
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'htransform'

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: htransform
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+  prerelease: 
+platform: ruby
+authors:
+- Josh Krueger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: HTransform provides a simple DSL to transform arbitrary hashes into another,
+  more arbitrary hash. Yay.
+email:
+- joshsinbox@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- examples/example.rb
+- examples/example_htransform.rb
+- htransform.gemspec
+- lib/htransform.rb
+- lib/htransform/version.rb
+- spec/htransform_nested_spec.rb
+- spec/htransform_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: HTransform transforms your hashes
+test_files:
+- spec/htransform_nested_spec.rb
+- spec/htransform_spec.rb
+- spec/spec_helper.rb
+has_rdoc: