tigon 0.0.1

data/Rakefile

@@ -0,0 +1,12 @@
+# Get your spec rake tasks working in RSpec 2.0
+
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end

data/lib/tigon.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/tigon/hash_transformer'
+require File.dirname(__FILE__) + '/tigon/hash_extensions'

data/lib/tigon/hash_extensions.rb

@@ -0,0 +1,7 @@
+class Hash
+  def transform(options = {}, &blk)
+    tr = Tigon::HashTransformer.new(self, :exclusive => !!options[:exclusive])
+    tr.instance_exec(&blk)
+    tr.new_hash
+  end
+end

data/lib/tigon/hash_transformer.rb

@@ -0,0 +1,77 @@
+module Tigon
+  class HashTransformer
+    def initialize(hash_or_value, options = {})
+      @options = options
+      @current_value = hash_or_value
+      if @current_value.is_a?(Hash) && !options[:exclusive]
+        @new_hash = @current_value
+      else
+        @new_hash = {}
+      end
+    end
+
+    def new_hash
+      @new_hash
+    end
+
+    def value
+      @current_value
+    end
+
+    def keep(name)
+      @new_hash[name] = @current_value[name]
+      @new_hash
+    end
+
+    def morph(name, newname = false, options = false, &blk)
+      options ||= @options
+
+      replacement_key = if newname
+        newname
+      else
+        if name.is_a?(String)
+          name
+        else
+          name.last #assumes an array was passed
+        end
+      end
+
+      if @current_value.is_a?(Hash) && (@current_value.key?(name) || (name.is_a?(Array) && @current_value.key?(name[0])))
+        if name.is_a?(Array)
+          current_val = furthest_value_from_hash(name, @current_value)
+        else
+          current_val = @current_value[name]
+        end
+
+        if block_given?
+          @new_hash[replacement_key] = nest_tranformation(current_val, replacement_key, options, blk)
+        else
+          @new_hash[replacement_key] = current_val
+        end
+        @new_hash.delete(name) if newname
+      end
+      @new_hash
+    end
+
+    def nest_tranformation(val, replacement_key, options, blk)
+        transformer = self.class.new(val, options)
+        transformed_val = transformer.instance_exec(&blk)
+
+        #preserve values from previous calls to morph
+        if transformed_val.is_a?(Hash) && @new_hash[replacement_key]
+          transformed_val = transformed_val.merge(@new_hash[replacement_key])
+        end
+        transformed_val
+    end
+
+    def furthest_value_from_hash(key_array, lookup_hash)
+      key_array.reduce(lookup_hash) do |context, k|
+        if context.is_a?(Hash)
+          context[k]
+        else
+          context
+        end
+      end
+    end
+  end
+end

data/lib/tigon/version.rb

@@ -0,0 +1,3 @@
+module Tigon
+  VERSION = "0.0.1"
+end

data/readme.markdown

@@ -0,0 +1,67 @@
+### Tigon adds a transform method to Hash, providing a means to rename and merge keys and manipulate their values.
+
+##Installation
+    gem install tigon
+
+##Usage
+    require 'tigon'
+
+    r = {
+      'followers_count' => '310000301',
+      'friends_count' => '6',
+      'listed_count' => '6',
+      'default_profile_image' => false,
+      'statuses_count' => '1'
+    }.transform(:exclusive => true) do
+      morph('followers_count', :friendships) do
+        {:followers => value.to_i}
+      end
+
+      morph('friends_count', :friendships) do
+        {:following => value.to_i}
+      end
+
+      morph('listed_count', :listed) do
+        value.to_i
+      end
+
+      morph('statuses_count', :statuses) do
+        value.to_i + 1
+      end
+    end
+
+    r == {
+      :friendships => {
+        :followers => 310000301,
+        :following => 6
+      },
+      :listed => 6,
+      :statuses => 2
+    } # true
+
+##LICENSE
+
+(The MIT License)
+
+Copyright © 2011:
+
+Max Justus Spransy
+
+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/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+require File.dirname(__FILE__) + '/../lib/tigon'
+
+RSpec.configure do |config|
+  
+end

data/spec/unit/hash_transformer_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+
+describe 'Hash' do
+  context 'transform' do
+    it 'takes a block in which you call morph - passing in the name of the key to morph, the new name, and an optional block to further transform the value(s)' do
+      h = {
+        'guy' => 'guy',
+        'cool' => {'stuff' => 'neat'},
+        'otherthing' => 'rad411'
+      }
+
+      h.transform do
+        morph('cool', :cool) do
+          morph('stuff', :stuff) {value.upcase}
+        end 
+        morph('otherthing', :thing) {value.gsub('rad','')}
+      end.should == {
+        'guy' => 'guy',
+        :cool => {:stuff => 'NEAT'},
+        :thing => '411'
+      }
+    end
+
+    it 'allows you to call morph without passing a block' do
+      h = {
+        'guy' => 'guy',
+        'cool' => {'stuff' => 'neat'},
+        'otherthing' => 'rad411'
+      }
+
+      h.transform do
+        morph('cool', :cool)
+      end.should == {
+        'guy' => 'guy',
+        :cool => {'stuff' => 'neat'},
+        'otherthing' => 'rad411'
+      }
+    end
+
+    it 'ignores transformations which are not present in source hash' do
+      h = {
+        'guy' => 'guy',
+        'cool' => {'stuff' => 'neat'},
+        'otherthing' => 'rad411'
+      }
+
+      h.transform do
+        morph(['cool', 'thing'], :cool)
+        morph('rawr', :cool)
+        morph('cool', :cool)
+      end.should == {
+        'guy' => 'guy',
+        :cool => {'stuff' => 'neat'},
+        'otherthing' => 'rad411'
+      }
+    end
+
+    it 'allows you to call morph with the name of the current key and a block' do
+      h = {
+        'guy' => 'guy',
+        'cool' => {'stuff' => 'neat'},
+        'otherthing' => 'rad411'
+      }
+      h.transform do
+        morph('cool') do
+          morph('stuff') do
+            value.upcase
+          end
+        end
+      end.should == {
+        'guy' => 'guy',
+        'cool' => {'stuff' => 'NEAT'},
+        'otherthing' => 'rad411'
+      }
+    end
+
+    it 'allows you to morph two different keys into the same key' do
+      h = {
+        'guy' => 'guy',
+        'cool' => {'stuff' => 'neat'},
+        'otherthing' => 'rad411'
+      }
+
+      h.transform(:exclusive => true) do
+        morph('guy', 'neat') do
+          {'man' => value}
+        end
+        morph('cool', 'neat') do
+          morph('stuff') do
+            value.upcase
+          end
+        end
+      end.should == {
+        'neat' => {
+          'man' => 'guy',
+          'stuff' => 'NEAT'
+        }
+      }
+    end
+
+    it 'allows you to pass an array to morph subhashes of the value of the key' do
+      h = {
+        'guy' => {'man' => 'bro'},
+        'cool' => {
+          'stuff' => 'neat',
+          'run' => 'fast'
+        },
+        'otherthing' => {
+          'rad411' => {'cool' => 'neat'}
+        },
+        'tools' => {
+          'hammer' => {
+            'rock' => {'stove' => 'iron'}
+          }
+        }
+      }
+
+      h.transform(:exclusive => true) do
+        morph(['cool', 'stuff'], 'neat') do
+          {'important' => value.upcase}
+        end
+
+        morph(['cool', 'run'], 'neat') do
+          {'run' => value}
+        end
+
+        morph(['otherthing', 'rad411', 'cool'], 'neat') do
+          {'critical' => value.upcase + 's'}
+        end
+
+        morph(['guy', 'man'], 'kewl') do
+          value.upcase
+        end
+
+        morph(['tools', 'hammer'], 'toolz')
+      end.should == {
+        'kewl' => 'BRO',
+        'neat' => {
+          'important' => 'NEAT',
+          'critical' => 'NEATs',
+          'run' => 'fast'
+        },
+        'toolz' => {
+          'rock' => {'stove' => 'iron'}
+        }
+      }
+    end
+
+    it 'allows you to call keep to keep a key if :exclusive is set to true' do
+      h = {
+        'guy' => 'guy',
+        'cool' => {'stuff' => 'neat'},
+        'otherthing' => 'rad411'
+      }
+
+      h.transform(:exclusive => true) do
+        morph('cool') do
+          morph('stuff') do
+            value.upcase
+          end
+        end
+        keep('guy')
+      end.should == {'guy' => 'guy', 'cool' => {'stuff' => 'NEAT'}}
+    end
+
+    it 'has an :exclusive option which restricts the returned hash to values passed to morph within block' do
+      h = {
+        'guy' => 'guy',
+        'cool' => {
+          'stuff' => 'neat',
+          'otherthing' => 'cool',
+          'thingthing' => {
+            't' => 't',
+            'thing' => 'thing'
+          }
+        },
+        'otherthing' => 'rad411'
+      }
+
+      h.transform(:exclusive => true) do
+        morph('cool', :cool) do
+          morph('stuff', :stuff) {value.upcase}
+          morph('thingthing', :thing, :exclusive => false) do
+            morph('thing') do
+              value.reverse
+            end
+          end
+        end 
+        morph('otherthing', :thing) {value.gsub('rad','')}
+      end.should == {
+        :cool => {
+          :stuff => 'NEAT',
+          :thing => {
+            'thing' => 'gniht',
+            't' => 't'
+          }
+        },
+        :thing => '411'
+      }
+    end
+  end
+end

data/tigon.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "tigon/version"
+
+Gem::Specification.new do |s|
+  s.name        = "tigon"
+  s.version     = Tigon::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Max Justus Spransy"]
+  s.email       = ["maxjustus@gmail.com"]
+  s.homepage    = "https://github.com/maxjustus/Tigon"
+  s.summary     = %q{A simple dsl for hash transformation.}
+  s.description = %q{
+      Tigon provides a declarative syntax for transforming hashes. 
+    }
+
+  s.rubyforge_project = "tigon"
+
+  s.add_development_dependency 'rspec', '~> 2.5.0'
+  s.add_development_dependency 'rake'
+
+  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"]
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: tigon
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Max Justus Spransy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-16 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.5.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: "\n      Tigon provides a declarative syntax for transforming hashes. \n    "
+email: 
+- maxjustus@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- lib/tigon.rb
+- lib/tigon/hash_extensions.rb
+- lib/tigon/hash_transformer.rb
+- lib/tigon/version.rb
+- readme.markdown
+- spec/spec_helper.rb
+- spec/unit/hash_transformer_spec.rb
+- tigon.gemspec
+has_rdoc: true
+homepage: https://github.com/maxjustus/Tigon
+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: tigon
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A simple dsl for hash transformation.
+test_files: 
+- spec/spec_helper.rb
+- spec/unit/hash_transformer_spec.rb