riffraff_jsonpath 0.8.2

data/.document

@@ -0,0 +1,3 @@
+README.markdown
+lib/**/*.rb
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Bruce Williams
+
+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.markdown

@@ -0,0 +1,102 @@
+# JSONPath
+
+JSONPath support for Ruby.
+
+For more information on JSONPath, see [Stefan Goessner's blog entry] [1], or
+the [JS and PHP implementations] [2] on Google Code.
+
+## Installing
+
+    gem install bruce-jsonpath --source 'http://gems.github.com'
+
+### Dependencies
+
+JSONPath uses [Treetop] [3] for parsing.
+
+## Completeness
+
+As of 2009-07-17, this implementation passes all tests from the
+[JS and PHP implementations] [2] (after modifying the script expressions
+for Ruby) -- in addition to its own expanded test suite.
+
+## Usage
+
+Execute JSONPath queries against a Ruby data
+structure (as would be parsed from JSON using the `json` or `yajl` gems).
+
+Only one method is needed:
+
+    JSONPath.lookup(hash_or_array, path)
+
+### Features
+
+It supports hash traversal by key:
+
+    JSONPath.lookup({"a" => 1}, '$.a')
+    # => [1]
+    JSONPath.lookup({"foo" => {"bar baz" => 2}}, "$.foo['bar baz']")
+    # => [2]
+    
+Array traversal by index, including `start:stop:step` slices:
+
+    JSONPath.lookup([1, 2, [3, 4, 5], 6], '$[2][-2:]')
+    # => [4, 5]
+    
+Wildcards:
+
+    JSONPath.lookup({"a" => {"b" => 3, "c" => 2}}, "$.a.*")
+    # => [3, 2]
+    
+Descendant traversal (think `//` in XPath):
+
+    JSONPath.lookup({'e' => 1, 'b' => [{'e' => 3}]}, '$..e')
+    # => [1, 3]
+    
+Peek at the tests for more ideas.
+    
+#### Experimental Support
+    
+It has experimental support for JSONPath's script expressions, including
+filters.  Since JSONPath uses the underlying language in script expressions,
+that means we have access to Ruby (supporting arbitrarily complex traversal).
+As in other JSONPath implementations, `@` is replaced by the current node.
+
+    lists = [
+      [1, 2, 3, 4],
+      [5, 6],
+      [7, 8, 9, 10]
+    ]
+    JSONPath.lookup(lists, "$.*[(@.length - 1)]")
+    => [4, 6, 10]
+
+And filters:
+
+    books = [
+      {"name" => 'Bruce', "age" => 29},
+      {"name" => "Braedyn", "age" => 3},
+      {"name" => "Jamis", "age" => 2},
+    ]
+    JSONPath.lookup(people, "$[?(@['age'] % 2 == 0)].name")
+    # => ['Jamis']
+
+For more information, see the the [JSONPath introductory article] [1].
+
+## Contributing and Reporting Issues
+
+The [project] [4] is hosted on [GitHub] [5], where I gladly accept pull
+requests.
+
+If you run into any problems, please either (in order of preference) post
+something on the [issue tracker] [6], send me a message on GitHub, or email me.
+
+## Copyright
+
+Copyright (c) 2009 Bruce Williams, based on work by Stefan Goessner.
+See LICENSE.
+
+[1]: http://goessner.net/articles/JsonPath/
+[2]: http://code.google.com/p/jsonpath/
+[3]: http://treetop.rubyforge.org/
+[4]: http://github.com/bruce/jsonpath
+[5]: http://github.com/
+[6]: http://github.com/bruce/jsonpath/issues

data/Rakefile

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "riffraff_jsonpath"
+    gem.summary = %Q{JSONPath support for Ruby}
+    gem.description = %Q{The gem implements a simple parser+evaluator for JSONPath expressions in Ruby. It is a fork of bruce-jsonpath which only adds support for underscore in fields and works with warnings enabled.}
+    gem.email = "rff.rff@gmail.com"
+    gem.homepage = "http://github.com/riffraff/jsonpath"
+    gem.authors = ["Gabriele Renzi"]
+    gem.add_dependency 'treetop'
+    # gem is a Gem::Specification... see http://  www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new  
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+    test.rcov_opts << '--exclude gems'
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "jsonpath #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+file 'lib/jsonpath/parser.rb' => 'lib/jsonpath/parser.treetop' do |t|
+  sh "tt 'lib/jsonpath/parser.treetop'"
+end
+
+task :treetop => 'lib/jsonpath/parser.rb'
+
+
+

data/VERSION

@@ -0,0 +1 @@
+0.8.2

data/jsonpath.gemspec

@@ -0,0 +1,59 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{jsonpath}
+  s.version = "0.8.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Gabriele Renzi"]
+  s.date = %q{2010-01-25}
+  s.description = %q{The gem implements a simple parser+evaluator for JSONPath expressions in Ruby. It is a fork of bruce-jsonpath which only adds support for underscore in fields and works with warnings enabled.}
+  s.email = %q{rff.rff@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "jsonpath.gemspec",
+     "lib/jsonpath.rb",
+     "lib/jsonpath/nodes.rb",
+     "lib/jsonpath/parser.rb",
+     "lib/jsonpath/parser.treetop",
+     "test/parser_test.rb",
+     "test/reference_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/riffraff/jsonpath}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{JSONPath support for Ruby}
+  s.test_files = [
+    "test/parser_test.rb",
+     "test/reference_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<treetop>, [">= 0"])
+    else
+      s.add_dependency(%q<treetop>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<treetop>, [">= 0"])
+  end
+end
+

data/lib/jsonpath.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'treetop'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'jsonpath/parser'
+require 'jsonpath/nodes'
+
+module JSONPath
+  
+  Parser = ::JSONPathGrammarParser
+  class ParseError < ::SyntaxError; end
+  
+  def self.lookup(obj, path)
+    parser = Parser.new
+    if (result = parser.parse(path))
+      result.walk(obj)
+    else
+      raise ParseError, parser.failure_reason
+    end
+  end
+  
+end

data/lib/jsonpath/nodes.rb

@@ -0,0 +1,213 @@
+module JSONPath
+    
+  module Nodes
+    
+    class RootNode < Treetop::Runtime::SyntaxNode
+      def walk(object)
+        selectors.elements.inject([object]) do |reduce, selector|
+          selector.descend(*reduce)
+        end
+      end
+    end
+    
+    class PathNode < Treetop::Runtime::SyntaxNode
+      
+      def traversing_descendants?
+        respond_to?(:lower) && lower.text_value == '..'
+      end
+      
+      def traverse(obj, &block)
+        if !respond_to?(:lower) || lower.text_value == '.'
+          obj.each(&block)
+        elsif lower.text_value == '..'
+          obj.each do |o|
+            recurse(o, &block)
+          end
+        end
+      end
+      
+      def recurse(obj, &block)
+        block.call(obj)
+        children = case obj
+        when Hash
+          obj.values
+        when Array
+          obj
+        else
+          return
+        end
+        children.each do |child|
+          recurse(child, &block)
+        end
+      end
+      
+    end
+    
+    class WildcardNode < PathNode
+      def descend(*objects)
+        results = []
+        traverse(objects) do |obj|
+          values = case obj
+          when Hash
+            obj.values
+          when Array
+            obj
+          else
+            next
+          end
+          results.push(*values)
+          # Note: I really don't like this special case.  This happens
+          # because when wildcarding regularly, the results are the *children*,
+          # but when using a .. descendant selector, you want the main parent,
+          # too.  According to the JSONPath docs, '$..*' means "All members of
+          # [the] JSON structure."  Should this support Array, as well?
+          if obj.is_a?(Hash) && traversing_descendants?
+            results.push(obj) unless results.include?(obj)
+          end
+        end
+        results
+      end
+    end
+    
+    class KeyNode < PathNode
+      
+      # supports finding the key from self or child elements
+      def find_keys(node=self, results=[], checked=[])
+        if node.respond_to?(:key)
+          results << node.key.text_value
+        end
+        if node.elements && !node.elements.empty?
+          node.elements.each do |element|
+            find_keys(element, results)
+          end
+        end
+        results
+      end
+            
+      def descend(*objects)
+        results = []
+        keys = find_keys
+        traverse(objects) do |obj|
+          if obj.is_a?(Hash)
+            keys.each do |key|
+              if obj.key?(key)
+                results << obj[key]
+              end
+            end
+          end
+        end
+        results
+      end
+    end
+    
+    class IndexNode < PathNode
+      def descend(*objects)
+        offset = Integer(index.text_value)
+        results = []
+        traverse(objects) do |obj|
+          if obj.is_a?(Array)
+            if obj.size > offset
+              results << obj[offset]
+            end
+          end
+        end
+        results
+      end
+    end
+    
+    class SliceNode < PathNode
+            
+      def descend(*objects)
+        results = []
+        traverse(objects) do |obj|
+          if obj.is_a?(Array)
+            values = obj[start_offset..stop_offset(obj)]
+            0.step(values.size - 1, step_size) do |n|
+              results << values[n]
+            end
+          end
+        end
+        results
+      end
+      
+      def start_offset
+        @start_offset ||= Integer(start.text_value)
+      end
+      
+      def stop_offset(obj)
+        @stop_offset ||= if respond_to?(:stop)
+          Integer(stop.text_value)
+        else
+          obj.size
+        end
+      end
+      
+      def step_size
+        @step_size ||= if respond_to?(:step)
+          Integer(step.text_value)
+        else
+          1
+        end
+      end
+      
+    end
+    
+    class CodeNode < PathNode
+      
+      def code
+        @code ||= begin
+          text = template_code.text_value
+          text.gsub('@', '(obj)').gsub('\\(obj)', '@')
+        end
+      end
+      
+      def execute(obj)
+        eval(code, binding)
+      end
+      
+    end
+    
+    class ExprNode < CodeNode
+            
+      def descend(*objects)
+        results = []
+        traverse(objects) do |obj|
+          res = execute(obj)
+          case obj
+          when Hash
+            next unless obj.key?(res)
+          when Array
+            next unless obj.size > res
+          else
+            next
+          end
+          results << obj[res]
+        end
+        results
+      end
+    
+    end
+    
+    class FilterNode < CodeNode
+      
+      class Error < ::ArgumentError; end
+      
+      def descend(*objects)
+        results = []
+        traverse(objects) do |set|
+          next unless set.is_a?(Array) || set.is_a?(Hash)
+          values = set.is_a?(Array) ? set : set.values
+          values.each do |obj|
+            if execute(obj)
+              results << obj
+            end
+          end
+        end
+        results
+      end
+    
+    end
+    
+  end
+  
+end