hash-tree 0.0.1

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2012 De Marque inc.
+
+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,37 @@
+Hash Tree
+===============
+
+[![Build Status](https://secure.travis-ci.org/demarque/hash-tree.png?branch=master)](http://travis-ci.org/demarque/hash-tree)
+
+Hash Tree gives you the abilty to manipulate nested hashes. The nodes of the hashes
+can be others hashes or even arrays of hashes.
+
+Install
+-------
+
+```
+gem install hash-tree
+```
+
+Rails 3
+-------
+
+In your Gemfile:
+
+```ruby
+gem 'hash-tree'
+```
+
+Usage
+-----
+
+**FILL THE USAGE**
+
+```ruby
+HashTree.new
+```
+
+Copyright
+---------
+
+Copyright (c) 2012 De Marque inc. See LICENSE for further details.

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler"
+require "rspec/core/rake_task"
+
+Bundler::GemHelper.install_tasks
+
+desc "Run all specs in spec directory"
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+task :default => :spec

data/lib/hash-tree.rb

@@ -0,0 +1,450 @@
+require 'json'
+require 'nori'
+
+class HashTree
+  #*************************************************************************************
+  # CONSTRUCTOR
+  #*************************************************************************************
+  def initialize(hash={})
+    hash = {} unless hash.is_a? Hash
+
+    @hash = hash
+  end
+
+
+  #*************************************************************************************
+  # PUBLIC CLASS METHODS
+  #*************************************************************************************
+  def self.from_json(json_data)
+    return nil if json_data.to_s.empty?
+
+    parsed_data = JSON.parse(json_data)
+
+    tree = self.new(parsed_data)
+    tree.replace_values!(nil, '')
+
+    return tree
+  end
+
+  def self.from_json_path(json_path)
+    from_json File.read(json_path)
+  end
+
+  def self.from_xml(xml_data)
+    return nil if xml_data.to_s.empty?
+
+    tree = self.new(Nori.parse(xml_data))
+    tree.replace_values!(nil, '')
+
+    return tree
+  end
+
+  def self.from_xml_path(xml_path)
+    from_xml File.read(xml_path)
+  end
+
+  def self.from_yml_path(yml_path)
+    yml_data = YAML.load_file(yml_path)
+
+    tree = self.new(yml_data)
+
+    return tree
+  end
+
+
+  #*************************************************************************************
+  # PUBLIC METHODS
+  #*************************************************************************************
+  def checksum
+    Digest::MD5.hexdigest(@hash.to_json.scan(/\S/).sort.join)
+  end
+
+  def children(name)
+    if @hash[name] and @hash[name][name.chop]
+      return [@hash[name][name.chop]].flatten
+    else
+      return []
+    end
+  end
+
+  def clone_tree
+    HashTree.new(Marshal.load(Marshal.dump(@hash)))
+  end
+
+  # Remove all key with a nil value
+  def compact!
+    @hash = compact
+  end
+
+  def each(options={}, &block)
+    options = { :hash => @hash, :key_path => [], :scope => nil }.merge(options)
+
+    options[:hash].each do |key, value|
+      key_path = [options[:key_path], key].flatten
+      key_path_string = key_path.join('.')
+
+      if in_scope?(key_path_string, options[:scope])
+        if (options[:scope] and options[:scope] == key_path_string)
+          yield options[:hash], key, value, key_path_string
+        else
+          cast(value, Array).each do |item|
+            if item.is_a? Hash
+              each(:hash => item, :key_path => key_path, :scope => options[:scope], &block)
+            else
+              yield options[:hash], key, item, key_path_string
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def empty?
+    @hash.empty?
+  end
+
+  def exists?(path='', hash=nil)
+    hash = @hash unless hash
+
+    path_parts = path.split('.')
+
+    hash.each do |key, value|
+      value_for_loop = (value.is_a? Array) ? value : [value]
+
+      if path_parts[0] == key
+        return true if path_parts.length == 1
+
+        value_for_loop.each do |item|
+          if item.is_a?(Hash)
+            return true if exists?(path_parts[1..-1].join('.'), item)
+          end
+        end
+
+      end
+    end
+
+    return false
+  end
+
+  def get(path='', options={})
+    options = { :default => '', :force => nil }.merge(options)
+
+    if not path.empty?
+      data = []
+      self.each(:scope => path) { |parent, k, v| data << cast(v, options[:force]) }
+      data = (data.length <= 1 ? data.first : data)
+    else
+      data = @hash
+    end
+
+    return (data == nil ? options[:default] : data)
+  end
+
+  def keys_to_s!(options={})
+    options = { :hash => nil }.merge(options)
+
+    options[:hash] = @hash unless options[:hash]
+
+    options[:hash].keys_to_s!
+
+    options[:hash].each do |key, value|
+      value_for_loop = (value.is_a? Array) ? value : [value]
+      value_for_loop.each { |item| keys_to_s!(:hash => item) if item.is_a? Hash }
+    end
+  end
+
+  def id
+    #override the id method of all object
+    get('id')
+  end
+
+  def insert(path, content)
+    current_value = get(path)
+
+    if current_value.is_a? Array
+      if content.is_a? Array
+        current_value = current_value.concat(content)
+      else
+        current_value << content
+      end
+    end
+
+    set(path, current_value)
+  end
+
+  def inspect(options={})
+    options = { :hash => nil, :position => 0, :raw => true }.merge(options)
+
+    options[:hash] = @hash unless options[:hash]
+
+    return options[:hash].inspect if options[:raw]
+
+    content = ""
+
+    options[:hash].each do |key, value|
+      convert_to_array(value).each do |item|
+        content << "\n" + ('   ' * options[:position]) + "#{key} : "
+        content << (item.is_a?(Hash) ? inspect(:hash => item, :position => options[:position]+1) : value.inspect)
+      end
+    end
+
+    return content
+  end
+
+  def merge(other_hash)
+    @hash = merge_children(@hash, other_hash)
+  end
+
+  def remove(path, options={})
+    options = { :if => nil, :remove_leaf => true, :unless => nil }.merge(options)
+
+    set(path, nil, options) if exists?(path)
+  end
+
+  def rename_key!(path, new_name, hash=nil)
+    hash = @hash unless hash
+
+    path_parts = path.split('.')
+
+    renamed_keys = {}
+
+    hash.each do |key, value|
+      if path_parts[0] == key
+        if path_parts.length == 1
+          renamed_keys[new_name] = hash.delete path_parts[0]
+        else
+          convert_to_array(value).each { |i| rename_key!(path_parts[1..-1].join('.'), new_name, i) if i.is_a? Hash }
+        end
+      end
+    end
+
+    hash.merge! renamed_keys if not renamed_keys.empty?
+  end
+
+  def replace_values!(old_value, new_value, hash=nil)
+    hash = @hash unless hash
+
+    hash.each do |key, value|
+      if value.is_a? Array
+        value.each do |item|
+          if item.is_a?(Hash)
+            item = replace_values!(old_value, new_value, item)
+          else
+            item = new_value if item == old_value
+          end
+        end
+      elsif value.is_a? Hash
+        value = replace_values!(old_value, new_value, value)
+      elsif value == old_value
+        value = new_value
+      end
+
+      hash[key] = value
+    end
+
+    return hash
+  end
+
+  def set(path, value, options={})
+    options = { :accept_nil => true, :if => nil, :remove_leaf => false, :unless => nil }.merge(options)
+
+    set_children(@hash, path, value, options) if options[:accept_nil] or value
+  end
+
+  def slash(path)
+    if exists?(path)
+      slashed_tree = get(path)
+      slashed_tree = slashed_tree.first if slashed_tree.is_a? Array and slashed_tree.length == 1 and slashed_tree.first.is_a? Hash
+    else
+      slashed_tree = @hash
+    end
+
+    return HashTree.new(slashed_tree)
+  end
+
+  def slash!(path)
+    @hash = slash(path).get
+  end
+
+  def to_json
+    @hash.to_json
+  end
+
+  def to_yaml
+    self.keys_to_s!
+
+    return @hash.ya2yaml
+  end
+
+  #*************************************************************************************
+  # PRIVATE METHODS
+  #*************************************************************************************
+  private
+
+  def compact(hash=nil)
+    hash = @hash unless hash
+
+    hash.each do |key, value|
+      if value.is_a? Array
+        hash[key] = compact_array value
+      elsif value.is_a? Hash
+        hash[key] = compact value
+      end
+    end
+
+    hash = compact_simple_hash(hash)
+
+    return (hash.empty? ? nil : hash)
+  end
+
+  def compact_array(array)
+    array.each { |item| item = compact(item) if item.is_a? Hash }
+    array.compact!
+
+    return (array.empty? ? nil : array)
+  end
+
+  def compact_simple_hash(hash)
+    hash.delete_if { |k,v| not v }
+  end
+
+  def cast(value, type)
+    case type.to_s
+      when 'Array' then convert_to_array value
+      when 'HashTree' then convert_to_hash_tree value
+      when 'String' then value.to_s
+      else value
+    end
+  end
+
+  def check_conditions(hash, conditions, comparaison = :if)
+    if conditions
+      conditions.each do |value, equal|
+        compare_values = hash
+        equal = [equal] unless equal.is_a? Array
+
+        path_value = value.split('.')
+        path_value.delete_at(0)
+
+        count = 0
+        path_value.each do |p|
+          if compare_values.is_a? Array
+            values = []
+            compare_values.each { |v| values << v[p] }
+            compare_values = values
+          elsif compare_values[p] != nil
+            compare_values = compare_values[p]
+          else
+            compare_values = nil
+            break
+          end
+          count += 1
+        end
+
+        if compare_values.is_a? Array
+          found = 0
+
+          compare_values.each { |v| found += 1 if equal.include?(v) }
+
+          if comparaison == :if and found == 0
+            return false
+          elsif comparaison == :unless and found > 0
+            return false
+          end
+        else
+          return false if comparaison == :if and not equal.include?(compare_values)
+          return false if comparaison == :unless and equal.include?(compare_values)
+        end
+      end
+    end
+
+    return true
+  end
+
+  def check_mixed_conditions(hash, if_conditions, unless_conditions)
+    valid = true
+
+    valid = check_conditions(hash, if_conditions, :if) if if_conditions
+    valid = check_conditions(hash, unless_conditions, :unless) if valid and unless_conditions
+
+    return valid
+  end
+
+  def convert_to_array(value)
+    value.is_a?(Array) ? value : [value]
+  end
+
+  def convert_to_hash_tree(value)
+    if value.is_a? HashTree
+      value
+    elsif value.is_a? Array
+      value.map{ |v| HashTree.new(v) }
+    else
+      HashTree.new(value)
+    end
+  end
+
+  def in_scope?(target, scope)
+    not scope or "^#{scope}".include? "^#{target}"
+  end
+
+  def merge_children(hash, other_hash)
+    other_hash = other_hash.get if other_hash.is_a? HashTree
+
+    if other_hash
+      other_hash.each do |key, value|
+        value = merge_children(hash[key], other_hash[key]) if hash[key] and value.is_a? Hash
+
+        hash[key] = value
+      end
+    end
+
+    return hash
+  end
+
+  def set_children(root, path, value, options={})
+    path = path.split('.')
+
+    selection = path[0]
+
+    setted = false
+
+    if path.length > 1
+      children = path.drop(1).join('.')
+
+      root[selection] = {} if not root[selection] or (not root[selection].is_a? Hash and not root[selection].is_a? Array)
+
+      if root[selection].is_a? Array
+        root[selection].each_with_index do |item, index|
+          set_children_node(root[selection][index], path, children, value, options) if item.is_a? Hash
+        end
+      else
+        set_children_node(root[selection], path, children, value, options)
+      end
+    else
+      root[selection] = value if check_mixed_conditions(root, options[:if], options[:unless])
+    end
+  end
+
+  def set_children_node(hash, path, children, value, options)
+    if options[:remove_leaf] and path.length == 2
+      if hash[children].is_a? Array
+        hash[children].delete_if{ |i| check_mixed_conditions(i, options[:if], options[:unless]) }
+        hash.delete(children) if hash[children].empty?
+      else
+        hash.delete(children) if check_mixed_conditions(hash[children], options[:if], options[:unless])
+      end
+    else
+      set_children(hash, children, value, options)
+    end
+  end
+
+  def method_missing(m, *args, &block)
+    if exists?(m.to_s)
+      return get(m.to_s)
+    else
+      return nil
+      #raise "DIG : The method #{m} doesn't exist in HashTree"
+    end
+  end
+end

data/spec/fixtures/book.json

@@ -0,0 +1,14 @@
+{
+  "book":
+    {
+      "id": 2,
+      "title": "Steppenwolf",
+      "author": ["Hermann Hesse"],
+      "formats": [
+        { "nature": "pdf", "price": [{ "amount": 799, "currency": "cad" }]},
+        { "nature": "epub", "price": [{ "amount": 799, "currency": "cad" }, { "amount": 759, "currency": "usd" }]}
+      ],
+      "tags": ["conflict", "isolation", "reality", "animalistic"],
+      "year": 1927
+    }
+}

data/spec/fixtures/books.json

@@ -0,0 +1,41 @@
+{
+  "books":[
+    {
+      "id": 1,
+      "title": "Don Quixote",
+      "summary": "The novel follows the adventures of Alonso Quijano, who reads too many chivalric novels, and sets out to revive chivalry under the name of Don Quixote.",
+      "author": ["Miguel de Cervantes"],
+      "formats": [
+        { "nature": "pdf", "prices": [{ "amount": 999, "currency": "cad" }]},
+        { "nature": "epub", "prices": [{ "amount": 1099, "currency": "cad" }, { "amount": 999, "currency": "usd" }]}
+      ],
+      "tags": ["realism", "chivalry", "satire", "deception"],
+      "year": 1615
+    },
+
+    {
+      "id": 2,
+      "title": "Steppenwolf",
+      "summary": null,
+      "author": ["Hermann Hesse"],
+      "formats": [
+        { "nature": "pdf", "prices": [{ "amount": 799, "currency": "cad" }]},
+        { "nature": "epub", "prices": [{ "amount": 799, "currency": "cad" }, { "amount": 759, "currency": "usd" }]}
+      ],
+      "tags": ["conflict", "isolation", "reality", "animalistic"],
+      "year": 1927
+    },
+
+    {
+      "id": 3,
+      "title": "The Idiot",
+      "summary": "",
+      "author": ["Fyodor Dostoyevsky"],
+      "formats": [
+        { "nature": "epub", "prices": [{ "amount": 1599, "currency": "cad" }] }
+      ],
+      "tags": [],
+      "year": 1869
+    }
+  ]
+}

data/spec/fixtures/books.xml

@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<books>
+  <book>
+    <id>1</id>
+    <title>Don Quixote</title>
+    <authors>
+      <author>Miguel de Cervantes</author>
+    </authors>
+    <formats>
+      <format>
+        <nature>pdf</nature>
+        <prices>
+          <price>
+            <amount>999</amount>
+            <currency>cad</currency>
+          </price>
+        </prices>
+      </format>
+      <format>
+        <nature>epub</nature>
+        <prices>
+          <price>
+            <amount>1099</amount>
+            <currency>cad</currency>
+          </price>
+          <price>
+            <amount>999</amount>
+            <currency>usd</currency>
+          </price>
+        </prices>
+      </format>
+    </formats>
+    <tags>
+      <tag>realism</tag>
+      <tag>chivalry</tag>
+      <tag>satire</tag>
+      <tag>deception</tag>
+    </tags>
+    <year>1615</year>
+  </book>
+
+  <book>
+    <id>2</id>
+    <title>Steppenwolf</title>
+    <authors>
+      <author>Hermann Hesse</author>
+    </authors>
+    <formats>
+      <format>
+        <nature>pdf</nature>
+        <prices>
+          <price>
+            <amount>799</amount>
+            <currency>cad</currency>
+          </price>
+        </prices>
+      </format>
+      <format>
+        <nature>epub</nature>
+        <prices>
+          <price>
+            <amount>799</amount>
+            <currency>cad</currency>
+          </price>
+          <price>
+            <amount>759</amount>
+            <currency>usd</currency>
+          </price>
+        </prices>
+      </format>
+    </formats>
+    <tags>
+      <tag>conflict</tag>
+      <tag>isolation</tag>
+      <tag>reality</tag>
+      <tag>animalistic</tag>
+    </tags>
+    <year>1927</year>
+  </book>
+
+  <book>
+    <id>3</id>
+    <title>The Idiot</title>
+    <authors>
+      <author>Fyodor Dostoyevsky</author>
+    </authors>
+    <formats>
+      <format>
+        <nature>epub</nature>
+        <prices>
+          <price>
+            <amount>1599</amount>
+            <currency>cad</currency>
+          </price>
+        </prices>
+      </format>
+    </formats>
+    <tags></tags>
+    <year>1869</year>
+  </book>
+</books>

data/spec/fixtures/books.yml

@@ -0,0 +1,73 @@
+---
+"books":
+  -
+    "id": 1
+    "title": "Don Quixote"
+    "author":
+      - "Miguel de Cervantes"
+    "formats":
+      -
+        "nature": "pdf"
+        "price":
+          -
+            "amount": 999
+            "currency": "cad"
+      -
+        "nature": "epub"
+        "price":
+          -
+            "amount": 1099
+            "currency": "cad"
+          -
+            "amount": 999
+            "currency": "usd"
+    "tags":
+      - "realism"
+      - "chivalry"
+      - "satire"
+      - "deception"
+    "year": 1615
+
+  -
+    "id": 2
+    "title": "Steppenwolf"
+    "author":
+      - "Hermann Hesse"
+    "formats":
+      -
+        "nature": "pdf"
+        "price":
+          -
+            "amount": 799
+            "currency": "cad"
+
+      -
+        "nature": "epub"
+        "price":
+          -
+            "amount": 799
+            "currency": "cad"
+          -
+            "amount": 759
+            "currency": "usd"
+    "tags":
+      - "conflict"
+      - "isolation"
+      - "reality"
+      - "animalistic"
+    "year": 1927
+
+  -
+    "id": 3
+    "title": "The Idiot"
+    "author":
+      - "Fyodor Dostoyevsky"
+    "formats":
+      -
+        "nature": "epub"
+        "price":
+          -
+            "amount": 1599
+            "currency": "cad"
+    "tags": ""
+    "year": 1869

data/spec/hash-tree_spec.rb

@@ -0,0 +1,239 @@
+require 'spec_helper'
+
+include ApplicationHelpers
+
+describe HashTree do
+  describe "::from_json" do
+    context "when using the books.json fixture" do
+      let(:hashtree) { HashTree.from_json(File.read('spec/fixtures/books.json')) }
+
+      subject { hashtree }
+
+      it { should_not be_empty }
+      the("hashtree.get('books').length") { should eql 3 }
+    end
+
+    context "when using an empty fixture" do
+      subject { HashTree.from_json('') }
+
+      it { should be_nil }
+    end
+  end
+
+  describe "::from_json_path" do
+    context "when using the books.json fixture" do
+      subject { HashTree.from_json_path('spec/fixtures/books.json') }
+      it { should_not be_empty }
+    end
+  end
+
+  describe "::from_xml" do
+    context "when using the books.xml fixture" do
+      let(:hashtree) { HashTree.from_xml(File.read('spec/fixtures/books.xml')) }
+
+      subject { hashtree }
+
+      it { should_not be_empty }
+      the("hashtree.get('books.book').length") { should eql 3 }
+    end
+
+    context "when using an empty fixture" do
+      subject { HashTree.from_xml('') }
+
+      it { should be_nil }
+    end
+  end
+
+  describe "::from_xml_path" do
+    context "when using the books.xml fixture" do
+      subject { HashTree.from_xml_path('spec/fixtures/books.xml') }
+      it { should_not be_empty }
+    end
+  end
+
+  describe "::from_yml_path" do
+    context "when using the books.yml fixture" do
+      let(:hashtree) { HashTree.from_yml_path('spec/fixtures/books.yml') }
+
+      subject { hashtree }
+
+      it { should_not be_empty }
+      the("hashtree.get('books').length") { should eql 3 }
+    end
+  end
+
+  describe "#checksum" do
+    context "with an empty hash" do
+      specify { HashTree.new.checksum.should eql '99914b932bd37a50b983c5e7c90ae93b' }
+    end
+
+    with_books_fixture do
+      specify { hashtree.checksum.should eql 'c15fddfa0bea3610663d019b8b5b4a4d' }
+    end
+  end
+
+  describe "#children" do
+    pending 'TOTEST'
+  end
+
+  describe "#clone_tree" do
+    with_books_fixture do
+      context "and cloning it" do
+        subject { hashtree.clone_tree }
+
+        its(:object_id) { should_not eql hashtree.object_id }
+      end
+    end
+  end
+
+  describe "#compact!" do
+    fixture :hashtree, HashTree.new({ 'books' => [ { 'title' => 'Don Quixote' }, { 'title' => nil }, { 'title' => 'Steppenwolf', 'formats' => [nil, 'pdf', 'epub'] } ]}) do
+      before { hashtree.compact! }
+
+      the("hashtree.get('books.title')") { should eql ['Don Quixote', 'Steppenwolf'] }
+      the("hashtree.get('books.formats')") { should eql ['pdf', 'epub'] }
+    end
+  end
+
+  describe "#each" do
+    pending 'TOTEST'
+  end
+
+  describe "#empty?" do
+    fixture :ht, HashTree.new do
+      it { should be_empty }
+    end
+
+    fixture :ht, HashTree.new({ 'book' => 'Steppenwolf' }) do
+      it { should_not be_empty }
+    end
+  end
+
+  describe "#exists?" do
+    fixture :hashtree, HashTree.new({ 'books' => [ { 'title' => 'Don Quixote' }, { 'formats' => [{ 'price' => 999 }] } ]}) do
+      the("hashtree.exists?('books.title')") { should be_true }
+      the("hashtree.exists?('books.formats.price')") { should be_true }
+      the("hashtree.exists?('books.unknown')") { should be_false }
+    end
+  end
+
+  describe "#get" do
+    fixture :books, HashTree.new({ 'books' => [ { 'title' => 'Don Quixote' }, { 'formats' => [{ 'nature' => 'pdf' }, {'nature' => 'epub' }] } ]}) do
+      the("books.get('books.title')") { should eql "Don Quixote" }
+      the("books.get('books.title', :force => Array)") { should eql ["Don Quixote"] }
+      the("books.get('books.formats')") { should eql [{ 'nature' => 'pdf' }, {'nature' => 'epub' }] }
+      the("books.get('books.formats.nature')") { should eql ['pdf', 'epub'] }
+      the("books.get('books.name')") { should eql "" }
+      the("books.get('books.name', :default => nil)") { should be_nil }
+    end
+  end
+
+  describe "#keys_to_s!" do
+    pending 'TOTEST'
+  end
+
+  describe "#id" do
+    context "with an hash tree having the attribute id with the value 123" do
+      subject { HashTree.new(:id => 123, :name => 'test') }
+
+      its(:id) { should eql 123 }
+    end
+  end
+
+  describe "#insert" do
+    pending 'TOTEST'
+  end
+
+  describe "#inspect" do
+    pending 'TOTEST'
+  end
+
+  describe "#merge" do
+    pending 'TOTEST'
+  end
+
+  describe "#remove" do
+    pending 'TOTEST'
+  end
+
+  describe "#rename_key!" do
+    with_books_fixture do
+      context "and renaming the key books.title for name" do
+        before { hashtree.rename_key! 'books.title', 'name' }
+
+        the("hashtree.exists?('books.title')") { should be_false }
+        the("hashtree.exists?('books.name')") { should be_true }
+      end
+
+      context "and renaming the key books.formats.prices.currency for specie" do
+        before { hashtree.rename_key! 'books.formats.prices.currency', 'specie' }
+
+        the("hashtree.exists?('books.formats.prices.currency')") { should be_false }
+        the("hashtree.exists?('books.formats.prices.specie')") { should be_true }
+      end
+    end
+  end
+
+  describe "#replace_values!" do
+    with_books_fixture do
+      the("hashtree.get('books.formats.nature')") { should include 'pdf' }
+
+      context "and replacing value pdf for paper" do
+        before { hashtree.replace_values!('pdf', 'paper') }
+        the("hashtree.get('books.formats.nature')") { should_not include 'pdf' }
+      end
+
+      context "and replacing value unknown for paper" do
+        before { hashtree.replace_values!('unknown', 'paper') }
+        the("hashtree.get('books.formats.nature')") { should include 'pdf' }
+      end
+    end
+  end
+
+  describe "#set" do
+    pending 'TOTEST'
+  end
+
+  describe "#slash" do
+    with_book_fixture do
+      context "and slashing book" do
+        subject { hashtree.slash 'book' }
+
+        its(:title) { should eql 'Steppenwolf' }
+        the("hashtree.book['title']") { should eql 'Steppenwolf' }
+      end
+
+      context "and not slashing book" do
+        its(:title) { should be_nil }
+      end
+    end
+  end
+
+  describe "#slash!" do
+    with_book_fixture do
+      context "and slashing book" do
+        before { hashtree.slash! 'book' }
+
+        its(:title) { should eql 'Steppenwolf' }
+        the("hashtree.book") { should be_nil }
+      end
+    end
+  end
+
+  describe "#to_json" do
+    with_books_fixture do
+      context "and converting it to json" do
+        subject { hashtree.to_json }
+
+        it { should_not be_empty }
+        it { should include '{"books":[{' }
+        it { should include '"tags":["conflict","isolation","reality","animalistic"]' }
+        it { should include '"author":["Fyodor Dostoyevsky"]' }
+      end
+    end
+  end
+
+  describe "#to_yaml" do
+    pending 'TOTEST'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require "rubygems"
+require "bundler/setup"
+
+require 'rspec'
+require 'rspec-aspic'
+
+require File.expand_path('../../lib/hash-tree', __FILE__)
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.include RSpecAspic
+end

data/spec/support/application_helpers.rb

@@ -0,0 +1,15 @@
+module ApplicationHelpers
+  def with_book_fixture(&block)
+    with_books_fixture('spec/fixtures/book.json', &block)
+  end
+
+  def with_books_fixture(file_path='spec/fixtures/books.json', &block)
+    context "when using the " + file_path.split('/').last + " fixture" do
+      let(:hashtree) { HashTree.from_json(File.read(file_path)) }
+
+      subject { hashtree }
+
+      self.instance_exec &block
+    end
+  end
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: hash-tree
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sebastien Rosa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &2157134360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157134360
+- !ruby/object:Gem::Dependency
+  name: ya2yaml
+  requirement: &2157133800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.30'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157133800
+- !ruby/object:Gem::Dependency
+  name: nori
+  requirement: &2157133320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157133320
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2157132840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: *2157132840
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2157132320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157132320
+- !ruby/object:Gem::Dependency
+  name: rspec-aspic
+  requirement: &2157131820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :development
+  prerelease: false
+  version_requirements: *2157131820
+- !ruby/object:Gem::Dependency
+  name: rspec-compact-doc-formatter
+  requirement: &2157131240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :development
+  prerelease: false
+  version_requirements: *2157131240
+description: HashTree help you to work with nested hashes and arrays.
+email:
+- sebastien@demarque.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- lib/hash-tree.rb
+- spec/fixtures/book.json
+- spec/fixtures/books.json
+- spec/fixtures/books.xml
+- spec/fixtures/books.yml
+- spec/hash-tree_spec.rb
+- spec/spec_helper.rb
+- spec/support/application_helpers.rb
+- LICENSE
+- README.md
+- Rakefile
+- Gemfile
+homepage: https://github.com/demarque/hash-tree
+licenses:
+- MIT
+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: hash-tree
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Manage nested hash
+test_files: []