hash_converter 0.0.2

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/.rspec

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

data/Gemfile

@@ -0,0 +1,2 @@
+source :gemcutter
+gemspec

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    hash_mapper (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.0)
+    mocha (0.9.8)
+      rake
+    rake (0.8.7)
+    rspec-core (2.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (>= 3.0.0)
+  bundler (>= 1.0.0)
+  hash_mapper!
+  mocha (>= 0.9.8)
+  rspec-core (>= 2.0.0)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Łukasz Strzałkowski, Peder Linder
+
+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,61 @@
+Hash Mapper
+===========
+
+Ruby DSL for parsing hashes.
+
+Installation
+------------
+
+hash_mapper is hosted on gemcutter.
+
+If you are using bundle (and you should):
+
+    gem 'hash_mapper'
+
+Run `bundle` and start hacking.
+
+Usage
+-----
+
+Simple example:
+
+    require "hash_converter"
+    hash = {
+      :person => {
+        :first_name => "Jonh",
+        :last_name => "Doe",
+        :address => {
+          :street => "Hoża",
+          :city => "Warsaw",
+          :zip => "12345"
+        }
+      }
+    }
+
+    hash_converted = HashConverter.convert(hash) do
+      path "person" do
+        map "{first_name} {last_name}", "name"
+        path "address" do
+          map "{street} {city} {zip}", "address"
+        end
+      end
+    end
+
+    pp hash_converted
+
+For more features, checkout tests. There are cool things like: #get, #set methods etc.
+
+Contributing
+------------
+
+* Fork the project.
+* Create branch for your changes
+* Write tests
+* Write change / fix
+* Commit
+* Pull request
+
+Author
+-------
+
+- Łukasz Strzałkowski (<http://github.com/strzalek>)

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/hash_mapper.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name        = "hash_converter"
+  s.version     = "0.0.2"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Łukasz Strzałkowski"]
+  s.email       = ["lukasz.strzalkowski@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/hash_converter"
+  s.summary     = "Parsing hashes made simple"
+  s.description = "Ruby DSL for parsing hashes"
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "hash_converter"
+
+  s.add_dependency "activesupport", ">= 3.0.0"
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rspec-core", ">= 2.0.0"
+  s.add_development_dependency "mocha", ">= 0.9.8"
+
+  s.files        = `git ls-files`.split("\n")
+  s.require_path = 'lib'
+end

data/lib/core_ext/hash.rb

@@ -0,0 +1,44 @@
+require "active_support/core_ext/hash/deep_merge"
+
+class Hash
+  @@namespace = []
+
+  def namespace_flatten(separator = ".")
+    hash = {}
+    self.each do |key, value|
+      key = key.to_s
+      if value.is_a?(Hash)
+        @@namespace << key
+        hash.merge! value.namespace_flatten(separator)
+        @@namespace.pop
+      else
+        key = @@namespace + [key]
+        hash[key.join(separator)] = value
+      end
+    end
+    hash
+  end
+
+  def namespace_unflatten(separator = ".")
+    hash = {}
+    self.each do |key, value|
+      hash.deep_merge! self.class.nested_value(value, key.split(separator))
+    end
+    hash
+  end
+
+  def self.nested_value(x, p)
+    hash = { p.pop => x }
+    p.reverse_each do |element|
+        hash = { element => hash }
+    end
+    hash
+  end
+
+  def recursive_symbolize_keys!
+    symbolize_keys!
+    values.each { |h| h.recursive_symbolize_keys! if h.is_a?(Hash) }
+    values.select { |v| v.is_a?(Array) }.flatten.each { |h| h.recursive_symbolize_keys! if h.is_a?(Hash) }
+    self
+  end
+end

data/lib/hash_converter.rb

@@ -0,0 +1,91 @@
+require "date"
+require "time"
+require "active_support/core_ext/hash/keys"
+require "core_ext/hash"
+
+class HashConverter
+  SEPARATOR = "."
+  KEY_REGEX = /\{([^}]*)\}/
+
+  Types = [String, Integer, Float, Time, Date, DateTime]
+
+  def self.convert(hash = {}, &block)
+    @hash = hash.namespace_flatten(SEPARATOR)
+    @converted = {}
+    @path = []
+
+    instance_eval(&block)
+
+    @converted.namespace_unflatten.recursive_symbolize_keys!
+  end
+
+  private
+
+    def self.path(path, &block)
+      @path.push(path)
+      instance_eval(&block)
+      @path.pop
+    end
+
+    def self.map(input, output, type_or_symbol = nil, &block)
+      value = if input =~ KEY_REGEX
+        input.gsub(KEY_REGEX) { |var| self.get(var.gsub(/\{|\}/,"")) }
+      else
+        self.get(input)
+      end
+
+      value = if type_or_symbol.is_a?(Symbol)
+        value.send(type_or_symbol)
+      elsif type_or_symbol.is_a?(Class)
+        typecast(value, type_or_symbol)
+      else
+        value
+      end
+
+      if block_given?
+        value = yield value
+      end
+
+      @converted[output.to_s] = value
+    end
+
+    def self.typecast(value, type)
+      return value if value.nil?
+
+      if Types.include?(type)
+        case type.to_s
+        when "String"
+          value.to_s
+        when "Integer"
+          value.to_i
+        when "Float"
+          value.to_f
+        when "Time"
+          Time.parse(value)
+        when "Date"
+          Date.parse(value)
+        when "DateTime"
+          DateTime.parse(value)
+        else
+          value
+        end
+      end
+    end
+
+    def self.namespaced_key(key)
+      (@path + [key]).join(SEPARATOR).to_s
+    end
+
+    def self.get(*keys)
+      values = []
+      keys.each do |key|
+        key = namespaced_key(key)
+        values <<  @hash[key]
+      end
+      values.length == 1 ? values.first : values
+    end
+
+    def self.set(key, value)
+      @converted[key] = value
+    end
+end

data/spec/lib/core_ext/hash_spec.rb

@@ -0,0 +1,219 @@
+require "spec_helper"
+
+describe Hash do
+  describe "#namespace_flatten" do
+    before do
+      @hash = {
+        :foobar => "a",
+        :foo => {
+          :bar => {
+            :text => "foobar"
+          },
+          :a => [1,2,3]
+        },
+        :b => "b"
+      }
+    end
+
+    it "should parse properly various hashes" do
+      {
+        :foo => {
+          :bar => {
+            :text => "foobar"
+          },
+          :test => {
+            :text => "tralalala"
+          },
+          :footest => {
+            :text => "asd"
+          }
+        }
+      }.namespace_flatten.should == {
+        "foo.bar.text" => "foobar",
+        "foo.test.text" => "tralalala",
+        "foo.footest.text" => "asd"
+      }
+
+      {
+        :foo => {
+          :bar => {
+            :text => "foobar"
+          },
+          :test => {
+            :text => "tralalala",
+            :text2 => "test"
+          }
+        }
+      }.namespace_flatten.should == {
+        "foo.bar.text" => "foobar",
+        "foo.test.text" => "tralalala",
+        "foo.test.text2" => "test"
+      }
+
+      {
+        :foo => {
+          :bar => "bar",
+          :foo => "foo",
+          :foobar => {
+            :bar => "bar",
+            :foo => "foo"
+          },
+          :barfoo => {
+            :bar => "bar",
+            :foo => "foo"
+          }
+        }
+      }.namespace_flatten.should == {
+        "foo.bar" => "bar",
+        "foo.foo" => "foo",
+        "foo.foobar.bar" => "bar",
+        "foo.foobar.foo" => "foo",
+        "foo.barfoo.bar" => "bar",
+        "foo.barfoo.foo" => "foo"
+      }
+    end
+
+    it "should return flatten hash with namespaced keys" do
+      result = {
+        "foobar" => "a",
+        "foo.bar.text" => "foobar",
+        "foo.a" => [1,2,3],
+        "b" => "b"
+      }
+
+      @hash.namespace_flatten.should == result
+    end
+
+    it "should flatten with custom separator" do
+      result = {
+        "foobar" => "a",
+        "foo/bar/text" => "foobar",
+        "foo/a" => [1,2,3],
+        "b" => "b"
+      }
+
+      @hash.namespace_flatten("/").should == result
+    end
+  end
+
+  describe "#namespace_unflatten" do
+    before do
+      @hash = {
+        "foobar" => "a",
+        "foo" => {
+          "bar" => {
+            "text" => "foobar"
+          },
+          "a" => [1,2,3]
+        },
+        "b" => "b"
+      }
+    end
+
+    it "should properly convert various hashes" do
+      {
+        "foo.bar.text" => "foobar",
+        "foo.test.text" => "tralalala",
+        "foo.footest.text" => "asd"
+      }.namespace_unflatten.should == {
+        "foo" => {
+          "bar" => {
+            "text" => "foobar"
+          },
+          "test" => {
+            "text" => "tralalala"
+          },
+          "footest" => {
+            "text" => "asd"
+          }
+        }
+      }
+
+      {
+        "foo.bar.text" => "foobar",
+        "foo.test.text" => "tralalala",
+        "foo.test.text2" => "test"
+      }.namespace_unflatten.should == {
+        "foo" => {
+          "bar" => {
+            "text" => "foobar"
+          },
+          "test" => {
+            "text" => "tralalala",
+            "text2" => "test"
+          }
+        }
+      }
+
+      {
+        "foo.bar" => "bar",
+        "foo.foo" => "foo",
+        "foo.foobar.bar" => "bar",
+        "foo.foobar.foo" => "foo",
+        "foo.barfoo.bar" => "bar",
+        "foo.barfoo.foo" => "foo"
+      }.namespace_unflatten.should == {
+        "foo" => {
+          "bar" => "bar",
+          "foo" => "foo",
+          "foobar" => {
+            "bar" => "bar",
+            "foo" => "foo"
+          },
+          "barfoo" => {
+            "bar" => "bar",
+            "foo" => "foo"
+          }
+        }
+      }
+    end
+
+    it "should return flatten hash with namespaced keys" do
+      {
+        "foobar" => "a",
+        "foo.bar.text" => "foobar",
+        "foo.a" => [1,2,3],
+        "b" => "b"
+      }.namespace_unflatten.should == @hash
+    end
+
+    it "should flatten with custom separator" do
+      {
+        "foobar" => "a",
+        "foo/bar/text" => "foobar",
+        "foo/a" => [1,2,3],
+        "b" => "b"
+      }.namespace_unflatten("/").should == @hash
+    end
+  end
+
+  describe "#nested_value" do
+    it "should generated nested hash" do
+      Hash.nested_value("value", ["foo", "bar", "foobar"]).should == {
+        "foo" => {
+          "bar" => {
+            "foobar" => "value"
+          }
+        }
+      }
+    end
+  end
+
+  describe "#def recursive_symbolize_keys!" do
+    it "should symbolize keys in nested hashes" do
+      { 
+        "foo" => {
+          "bar" => {
+            "foobar" => "foobar"
+          }
+        }
+      }.recursive_symbolize_keys!.should == {
+        :foo => {
+          :bar => {
+            :foobar => "foobar"
+          }
+        }
+      }
+    end
+  end
+end

data/spec/lib/hash_mapper_spec.rb

@@ -0,0 +1,261 @@
+require "spec_helper"
+
+describe HashConverter do
+  describe "DSL" do
+    describe "maping" do
+      it "should map from flat hash" do
+        HashConverter.convert({ :key1 => "val1", :key2 => "val2", :key3 => "val3" }) do
+          map "key1", "a"
+          map "key2", "b"
+          map "key3", "c"
+        end.should == { :a => "val1", :b => "val2", :c => "val3" }
+      end
+
+      it "should map keys that not exists as nil value" do
+        HashConverter.convert({ :key => "value", :nilkey => nil }) {
+          map "key", "foo"
+          map "foobar", "foobar"
+          map "nilkey", "nil"
+        }.should == {
+          :foo => "value",
+          :foobar => nil,
+          :nil => nil
+        }
+      end
+
+      it "should map keys given as symbol" do
+        h = { :key => "value" }
+        hh = { :new_key => "value" }
+
+        HashConverter.convert(h) do
+          map :key, :new_key
+        end.should == hh
+
+        HashConverter.convert(h) do
+          map "key", :new_key
+        end.should == hh
+
+        HashConverter.convert(h) do
+          map :key, "new_key"
+        end.should == hh
+      end
+    end
+
+    describe "nesting paths" do
+      before do
+        @hash = {
+          :foo => {
+            :bar => {
+              :text => "foobar"
+            },
+            :test => {
+              :text => "text"
+            }
+          }
+        }
+      end
+
+      it "should take namespaced path name" do
+        HashConverter.convert(@hash) do
+          path "foo.bar" do
+            map :text, :foo
+          end
+        end.should == { :foo => "foobar" }
+      end
+
+      it "should allow take symbol as argument" do
+        HashConverter.convert(@hash) do
+          path :foo do
+            path :bar do
+              map :text, :barfoo
+            end
+          end
+          path :foo do
+            path :test do
+              map :text, :testfoo
+            end
+          end
+        end.should == { :barfoo => "foobar", :testfoo => "text" }
+      end
+
+      it "should allow take string as argument" do
+        HashConverter.convert(@hash) do
+          path "foo" do
+            path "bar" do
+              map :text, :barfoo
+            end
+          end
+
+          path "foo" do
+            path "test" do
+              map :text, :testfoo
+            end
+          end
+        end.should == { :barfoo => "foobar", :testfoo => "text" }
+      end
+    end
+
+    describe "combined input keys" do
+      it "should join with given white chars" do
+        HashConverter.convert({ :foo => "foo", :bar => "bar" }){
+          map "{foo}\s{bar}", :foobar
+        }.should == {
+          :foobar => "foo\sbar"
+        }
+      end
+
+      it "should join namespaecd keys with given white chars" do
+        HashConverter.convert({ :ns => { :foo => "foo", :bar => "bar" }}){
+          map "{ns.foo}\s{ns.bar}", :foobar
+        }.should == {
+          :foobar => "foo\sbar"
+        }
+      end
+    end
+
+    describe "value conversion" do
+      it "should change value passed in block" do
+        h = {
+          :test => {
+            :valid => "test"
+          }
+        }
+
+        HashConverter.convert(h) do
+          path "test" do
+            map "valid", "foobar" do |value|
+              "value_from_block_#{value}"
+            end
+          end
+        end.should == { :foobar => "value_from_block_test" }
+      end
+    end
+
+    describe "typecasting" do
+      it "should typecast to given type" do
+        HashConverter.convert({ :foobar => "123" }){
+          map :foobar, :foo, Integer
+        }.should == {
+          :foo => 123
+        }
+      end
+
+      it "should invoke method given by symbol" do
+        HashConverter.convert({ :foobar => "123" }){
+          map :foobar, :foo, :to_i
+        }.should == {
+          :foo => 123
+        }
+      end
+    end
+
+    describe "#get" do
+      before do
+        @hash = { :foo => { :bar => "foobar" }, :bar => "foo"}
+      end
+
+      it "should return value from given hash" do
+        HashConverter.convert(@hash) {
+         @@var = get "foo.bar"
+        }
+        @@var.should == "foobar"
+      end
+
+      it "should return array of values" do
+        HashConverter.convert(@hash) {
+         @@var = get("foo.bar", "bar")
+        }
+        @@var.should == ["foobar", "foo"]
+      end
+
+      it "should works properly when nested into path" do
+        HashConverter.convert(@hash) {
+          path "foo" do
+            @@var = get "bar"
+          end
+        }
+
+        @@var.should == "foobar"
+      end
+    end
+
+    describe "#set" do
+      it "should set value for key" do
+        HashConverter.convert {
+          set "foo", "bar"
+        }.should == {
+          :foo => "bar"
+        }
+      end
+
+      it "should set value for namespaced key" do
+        HashConverter.convert {
+          set "foo.bar", "foobar"
+        }.should == {
+          :foo => {
+            :bar => "foobar"
+          }
+        }
+      end
+
+      it "should ignore path" do
+        HashConverter.convert do
+          path "ns" do
+            set "foo.bar", "foobar"
+          end
+        end.should == {
+          :foo => {
+            :bar => "foobar"
+          }
+        }
+      end
+    end
+
+    describe "get and set combined" do
+      it "should set value from #get" do
+        HashConverter.convert({ "foo" => { "bar" => "foobar" }}) {
+          set "test", get("foo.bar")
+        }.should == {
+          :test => "foobar"
+        }
+      end
+    end
+  end
+
+  describe "#typecast" do
+    describe "casting to type" do
+
+      it "should handle nils properly" do
+        lambda {
+          HashConverter.convert do
+            map "foo", "foobar", Date
+          end
+        }.should_not raise_error
+      end
+
+      it "string" do
+        HashConverter.typecast(123, String).should == "123"
+      end
+
+      it "integer" do
+        HashConverter.typecast("123", Integer).should == 123
+      end
+
+      it "float" do
+        HashConverter.typecast("123.45", Float).should == 123.45
+      end
+
+      it "time" do
+        HashConverter.typecast("16:30", Time).should == Time.parse("16:30")
+      end
+
+      it "date" do
+        HashConverter.typecast("01-02-2003", Date).should == Date.parse("01-02-2003")
+      end
+
+      it "datetime" do
+        HashConverter.typecast("01-02-2003 15:30", DateTime).should == DateTime.parse("01-02-2003 15:30")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require "hash_mapper"
+require "rspec"
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification 
+name: hash_converter
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- "\xC5\x81ukasz Strza\xC5\x82kowski"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-12 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec-core
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 0
+        - 9
+        - 8
+        version: 0.9.8
+  type: :development
+  version_requirements: *id004
+description: Ruby DSL for parsing hashes
+email: 
+- lukasz.strzalkowski@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- hash_mapper.gemspec
+- lib/core_ext/hash.rb
+- lib/hash_converter.rb
+- spec/lib/core_ext/hash_spec.rb
+- spec/lib/hash_mapper_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/hash_converter
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: hash_converter
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Parsing hashes made simple
+test_files: []
+