walky 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+Gemfile.lock
+.rspec
+.rvmrc
+autotest/
+*.swp
+*.gem

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+script: rspec

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,44 @@
+## Walky - Simple lib to walky through easily hashes
+
+[![Build
+Status](https://secure.travis-ci.org/jhonnyquest/walky.png?branch=master)](http://travis-ci.org/jhonnyquest/walky)
+
+
+Walky try create a simple way to access hashes with many keys easily. 
+You can move through hashes and also access others hashes with the _same path_
+
+Example:
+
+```ruby
+@hash = { "menu" => { 
+  "header"   => {
+    "screen" => "LCD", 
+    "meme"   => "Like a boss"
+  }
+}
+```
+
+If we have an hash like above, you can use Walky like this:
+
+```ruby
+@walky = Walky::Walker.new(@hash)
+
+@walky["menu header screen"]      # => "LCD"
+# Or:
+@walky.walk("menu header screen") # => "LCD" 
+```
+
+If you want to access multiple hashes that have the same keys that the first, you can use
+<tt>Walky#same_path</tt>. Example using with the code above:
+
+```ruby
+@other    = { "menu" => { "header" => { "screen" => "LED"  , "meme" => "Poker face" } } }
+@more_one = { "menu" => { "header" => { "screen" => "PLASM", "meme" => "LOL"        } } }
+  
+# Acessing multiple hashes with one hash key
+@walky["menu header"].same_path(@other, @more_one).all do |a, b, c|
+  a["screen"] # => "LCD"
+  b["screen"] # => "LED"
+  c["screen"] # => "PLASM"
+end
+```

data/kronix.yml

@@ -0,0 +1,2 @@
+run: rspec
+project: git://github.com/jhonnyquest/walky.git

data/lib/walky.rb

@@ -0,0 +1,44 @@
+require 'walky/version'
+require 'walky/parser'
+require 'walky/walk_methods'
+require 'walky/instance_methods'
+
+module Walky
+  def self.move(hash, path)
+    Walky::Parser.parse(hash, path)
+  end
+
+  def self.extract(hash, path)
+    Walky::Parser.extract(hash, path)
+  end
+
+  def self.extract_with_sym(hash, path)
+    Walky::Parser.extract_with_sym(hash, path)
+  end
+
+  class Walker
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def [](path)
+      parse(path)
+    end
+
+    def walk(path)
+      parse(path)
+    end
+
+    def parse(path)
+      Walker.parse(@hash, path)
+    end
+
+    def self.parse(hash, path)
+      Walky::Parser.parse(hash, path)
+    end
+
+    def extract(path)
+      Walky::Parser.extract(@hash, path)
+    end
+  end
+end

data/lib/walky/instance_methods.rb

@@ -0,0 +1,15 @@
+module Walky
+  module InstanceMethods
+    attr_accessor :walky_path
+
+    def same_path(*other)
+      [].tap do | ary |
+        ary << self
+        other.each do |o|
+          ary << Walker.parse(o, @walky_path)
+        end
+        ary.extend WalkMethods
+      end
+    end
+  end
+end

data/lib/walky/parser.rb

@@ -0,0 +1,36 @@
+module Walky
+  module Parser
+    def self.parse(hash, path)
+      paths = path.split(" ")
+      return_hash = hash
+      paths.each do |pathy|
+        if pathy =~ /^:/
+          return_hash = return_hash[pathy.gsub(":", "").to_sym]
+        else
+          return_hash = return_hash[pathy]
+        end
+      end
+
+      return_hash.extend InstanceMethods
+      return_hash.walky_path = path
+
+      return_hash
+    end
+
+    def self.extract(hash, path)
+      Walky.move(hash, path)
+    end
+
+    def self.extract_with_sym(hash, path)
+      symbolize_keys(extract(hash, path))
+    end
+
+    def self.symbolize_keys(hash)
+      {}.tap do |h|
+        hash.each do |key, value|
+          h[key.to_sym] = value
+        end
+      end
+    end
+  end
+end

data/lib/walky/version.rb

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

data/lib/walky/walk_methods.rb

@@ -0,0 +1,9 @@
+module Walky
+  module WalkMethods
+    def all(&block)
+      if block_given?
+        yield(self)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'test_notifier/runner/rspec'

data/spec/walky_spec.rb

@@ -0,0 +1,138 @@
+require 'walky'
+
+describe Walky do
+
+  before do
+    @hash = {"menu"=>{"header"=> {"screen"=>"LCD", "meme" => "Like a boss"}}}
+    @other = {"menu"=>{"header"=> {"screen"=>"LED", "meme" => "Poker face"}}}
+    @more_one = {"menu"=>{"header"=> {"screen"=>"PLASM", "meme" => "LOL"}}}
+    @menu_items = {
+      "menu" => {
+        "items" => [
+          {"item" => "Movie", "cat" => { "keywords" => ["movie", "stories"]}}, 
+          {"item" => "Shop", "cat" => {"keywords" => ["buy", "bussiness"]}}, 
+          {"item" => "Stadium", "cat" => {"keywords" => ["joy", "watch", "fun"]}}, 
+        ]
+      }
+    }
+
+    @collection = Walky::Walker.new(@menu_items)
+    @walky = Walky::Walker.new(@hash)
+  end
+
+  describe "Parse to walk" do
+    it "shoul have Walky#[] method" do
+      @walky.should respond_to(:[])
+    end
+
+    it "should parse a simple path" do
+      @walky["menu"].should be_kind_of(Hash)
+    end
+
+    it "should parse a two level path" do
+      @walky["menu header"].should be_kind_of(Hash)
+    end
+
+    it "should parse a last level path" do
+      @walky["menu header screen"].should == "LCD" 
+    end
+
+    it "should parse by :[] or :walk" do
+      @walky["menu header screen"].should == "LCD" 
+      @walky.walk("menu header screen").should == "LCD" 
+    end
+  end
+
+  describe "Walk through hash" do
+    it "should access other with same path" do
+      @walky["menu header"].same_path(@other).should be_kind_of(Array)
+      @walky["menu header"].same_path(@other)[0].should == @walky["menu header"]
+      @walky["menu header"].same_path(@other)[1].should == @other["menu"]["header"]
+    end
+
+    it "should access multiple other hashes with same path" do
+      walked = @walky["menu header"].same_path(@other, @more_one)
+      walked.size.should == 3
+      walked[0].should == @walky["menu header"]
+      walked[1].should == @other["menu"]["header"]
+      walked[2].should == @more_one["menu"]["header"]
+    end
+
+    it "should take all sub hashes with same path" do
+      walked = @walky["menu header"].same_path(@other, @more_one).all do |a, b, c|
+        a["screen"].should == "LCD"
+        b["screen"].should == "LED"
+        c["screen"].should == "PLASM"
+
+        "#{a["screen"]}#{b["screen"]}#{c["screen"]}"
+      end
+      walked.should == "LCDLEDPLASM"
+    end
+
+    it "should iterate between hashes collection" do
+      @collection["menu items"].each do |item|
+        item["item"].should_not be_nil
+      end
+    end
+
+    it "should be able to navigate trough an hash" do
+      @collection["menu items"].each do |item|
+        Walky.move(item, "cat keywords").should be_kind_of(Array)
+      end
+
+      Walky.move(@collection["menu items"].first, "cat keywords").size.should == 2
+    end
+
+    it 'should walky with symbol keys' do
+      command = {
+        :type => "ls",
+        :params => ["l", "a"]
+      }
+      Walky.move(command, ":type").should == "ls"
+      Walky.move(command, ":params").should == ["l", "a"]
+    end
+
+    it 'should walky with symbols and string keys' do
+      print = {
+        "file" => {
+          :type => "A4",
+          :pages => [1, 2, 3],
+          "password" => "secret"
+        }
+      }
+      Walky.move(print, "file :type").should == "A4"
+      Walky.move(print, "file password").should == "secret"
+    end
+
+    it "should access keys from a sub key" do
+      print = {
+        "file" => {
+          :type => "A4",
+          :pages => [1, 2, 3],
+          "password" => "secret"
+        }
+      }
+      keys = Walky.extract(print, "file")
+      keys[:type].should == "A4"
+      keys[:pages].should == [1, 2, 3]
+      keys["password"].should == "secret"
+
+      extracted = @walky.extract("menu header")
+      extracted["screen"] = "LCD"
+    end
+
+    it "should access keys from a sub key and symbolize" do
+      print = {
+        "file" => {
+          :type => "A4",
+          :pages => [1, 2, 3],
+          "password" => "secret"
+        }
+      }
+
+      keys = Walky.extract_with_sym(print, "file")
+      keys[:type].should == "A4"
+      keys[:password].should == "secret"
+    end
+  end
+end

data/walky.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "walky/version"
+
+Gem::Specification.new do |s|
+  s.name          = "walky"
+  s.version       = Walky::VERSION
+  s.authors       = ["Jonathan Duarte"]
+  s.email         = ["jonathan.duarte@rocketmail.com"]
+  s.homepage      = "http://www.jonathanduarte.com.br"
+  s.summary       = "Walky through hashes"
+  s.description   = "Simple way to access hashes with nested keys"
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec}/*`.split("\n")
+
+  s.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: walky
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jonathan Duarte
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &74795770 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *74795770
+description: Simple way to access hashes with nested keys
+email:
+- jonathan.duarte@rocketmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- README.md
+- kronix.yml
+- lib/walky.rb
+- lib/walky/instance_methods.rb
+- lib/walky/parser.rb
+- lib/walky/version.rb
+- lib/walky/walk_methods.rb
+- spec/spec_helper.rb
+- spec/walky_spec.rb
+- walky.gemspec
+homepage: http://www.jonathanduarte.com.br
+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.10
+signing_key: 
+specification_version: 3
+summary: Walky through hashes
+test_files: []