jpath 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 457110306795a1ccec58c95678abe4ffba72799a
+  data.tar.gz: d36bbbe5ffc6d83dc9b2d48842a6edb05320c839
+SHA512:
+  metadata.gz: ec250f68aa9480e96ff7ed5fba174eecdecf7bb89b14ba584f1b8f945c7e81bab2a34cc287e3f4ac90b3aa04fde54fe99a418713a366d0c10abd2b61229ac539
+  data.tar.gz: 1379625372cb7675bac5cb2c9ac400748d26559b70147ad3eec33b52fa41e027bb2ab6c7aa9b3ce724e45244523aca666a474af6773c882bc169f75efe4fe1a9

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Merimond Corporation
+
+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,58 @@
+# JPath
+
+JPath is a Ruby library that allows to execute XPath queries on JSON documents.
+
+### Installation
+
+JPath doesn't use any dependencies. Simply install via rubygems:
+
+    gem install jpath
+
+or clone it from github:
+
+    git clone https://github.com/merimond/jpath.git
+
+JPath is in early beta stage. So having an up-to-date Git version is more preferable.
+
+## Library
+
+Please note that JPath works with *standard* XPath syntax, not one of XPath alternatives, such as the great [JSONPath](http://goessner.net/articles/JsonPath/) syntax by Stefan Goessner. If you prefer the latter, there's a [terrific library](https://github.com/joshbuddy/jsonpath) by Joshua Hull that you should check out.
+
+### A few caveats
+
+Although JSON and XML are both data containers, they are quite different when it comes to searching and manipulating data. So JPath _may_ behave somewhat differently from what you woud expect, although we tried to make some sensible assumptions while transforming the XML-oriented search paradigm into the JSON world.
+
+## Features
+
+JPath support all the basic and some of the more advanced XPath functions:
+
+Simple chains with children and ancestors:
+
+    /store/book/author
+    //author
+    /store/*
+    
+Position predicates:
+
+    //book[last()]
+    //book[position()<3]
+
+Attribute and child predicates:
+
+    //book[@price<10]
+    //book[isbn]
+
+Multiple predicates:
+
+    //book[@price>10][last()]
+
+And all of the above in non-abbreviated form:
+
+    /descendant::book
+    /child::book[attribute::price="8.95"]
+
+Test files are a bit of a mess at the moment, but they should give you an indication of what's currently supported.
+
+## Contributing
+
+Fork, send pull requests, file bug reports -- any help is welcome.

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'bundler'
+require 'rspec/core/rake_task'
+
+Bundler.require
+Bundler::GemHelper.install_tasks
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  # nothing
+end
+
+task :default => :spec

data/lib/jpath.rb

@@ -0,0 +1,21 @@
+module JPath
+  
+  require 'strscan'
+  require 'json'
+  
+  require_relative "jpath/item"
+  require_relative "jpath/pointer"
+  require_relative "jpath/parser"
+  require_relative "jpath/parser/formula"
+  require_relative "jpath/parser/step"
+  require_relative "jpath/parser/path"
+  
+  def self.find(json, xpath)
+    parse(xpath).from(json)
+  end
+  
+  def self.parse(xpath)
+    Parser.path(xpath)
+  end
+  
+end

data/lib/jpath/item.rb

@@ -0,0 +1,138 @@
+module JPath
+  class Item
+    
+    def initialize(hash)
+      @hash = hash
+    end
+    
+    def [](pointer)
+      result = @hash
+      if pointer.is_a?(String)
+        pointer = Pointer.parse(pointer)
+      end
+      pointer.each do |key|
+        unless result.is_a?(Array) or result.is_a?(Hash)
+          return nil
+        end
+        if result.is_a?(Array) && !key.is_a?(Numeric)
+          return nil
+        end
+        result = result[key]
+      end
+      result
+    end
+    
+    def parent(pointer)
+      if pointer.is_a?(String)
+        pointer = Pointer.parse(pointer)
+      end
+      if pointer.top?
+        return nil
+      end
+      if pointer.index?
+        pointer.grandparent
+      else
+        pointer.parent
+      end
+    end
+    
+    def ancestors(pointer)
+      if pointer.is_a?(String)
+        pointer = Pointer.parse(pointer)
+      end
+      obj = parent(pointer)
+      if obj.nil?
+        []
+      else
+        [obj, ancestors(obj)].flatten
+      end
+    end
+    
+    def attributes(pointer)
+      enum_for(:each_attribute, pointer)
+    end
+    
+    def children(pointer)
+      enum_for(:each_child, pointer)
+    end
+    
+    def descendants(pointer)
+      enum_for(:each_descendant, pointer)
+    end
+    
+    def following(pointer)
+      enum_for(:each_following, pointer)
+    end
+    
+    def preceding(pointer)
+      enum_for(:each_preceding, pointer)
+    end
+    
+    private
+    
+    def each_attribute(pointer)
+      children(pointer).select do |child|
+        unless self[child].is_a?(Hash)
+          yield child
+        end
+      end
+    end
+    
+    def each_child(pointer, &block)
+      if pointer.is_a?(String)
+        pointer = Pointer.parse(pointer)
+      end
+      obj = self[pointer]
+      if obj.is_a?(Hash)
+        obj.each do |key, value|
+          if value.is_a?(Array)
+            each_child(pointer + key, &block)
+          else
+            yield pointer + key
+          end
+        end
+      end
+      if obj.is_a?(Array)
+        obj.each_with_index do |item, index|
+          yield pointer + index
+        end
+      end
+    end
+    
+    def each_descendant(pointer)
+      children(pointer).each do |p1|
+        yield p1
+        each_descendant(p1) do |p2|
+          yield p2
+        end
+      end
+    end
+    
+    def each_following(pointer)
+      flag   = false
+      parent = parent(pointer)
+      each_child(parent) do |child|
+        if flag
+          yield child
+        end
+        if child == pointer
+          flag = true
+        end
+      end
+    end
+
+    def each_preceding(pointer)
+      flag   = true
+      parent = parent(pointer)
+      each_child(parent) do |child|
+        if child == pointer
+          flag = false
+        end
+        if flag
+          yield child
+        end
+      end
+    end
+    
+  end
+end

data/lib/jpath/parser.rb

@@ -0,0 +1,128 @@
+module JPath
+  module Parser
+    
+    def self.path(s)
+      unless s.is_a?(StringScanner)
+        s = StringScanner.new(s)
+      end
+      Path.new do |path|
+        each_step(s) do |step|
+          path << step
+        end
+      end
+    end
+    
+    def self.predicates(s)
+      enum_for(:each_predicate, s).to_a
+    end
+    
+    def self.steps(s)
+      enum_for(:each_step, s).to_a
+    end
+    
+    def self.expressions(s)
+      enum_for(:each_expression, s).to_a
+    end
+    
+    private
+    
+    def self.next_expression(s)
+      if s.scan /position\(\)/
+        return Position.new
+      end
+      if s.scan /(\d+\.\d+)/
+        return Number.new(s[1].to_f)
+      end
+      if s.scan /(\d+)/
+        return Number.new(s[1].to_i)
+      end
+      if s.scan /@([\w*]+)/
+        return Attribute.new(s[1])
+      end
+      if s.scan /\=/
+        return Operator.new("=")
+      end
+      if s.scan /</
+        return Operator.new("<")
+      end
+      if s.scan />/
+        return Operator.new(">")
+      end
+      if s.scan /"([^"]+)"/
+        return Literal.new(s[1])
+      end
+    end
+    
+    def self.each_expression(s)
+      until s.eos?
+        obj = next_expression(s)
+        break if obj.nil?
+        yield obj
+      end
+    end
+    
+    def self.next_predicate(s)
+      if s.scan /\[(\d+)\]/
+        return Formula.new("=", Position.new, Number.new(s[1].to_i)).to_predicate
+      end
+      if s.scan /\[last\(\)\]/
+        return Formula.new("=", Position.new, Last.new).to_predicate
+      end
+      if s.scan /\[@?([\w*]+)\]/
+        return Predicate.new(Contains.new(Attribute.new(s[1])))
+      end
+      unless s.scan(/\[/)
+        return
+      end
+      exp = expressions(s).inject do |result, expression|
+        result + expression
+      end
+      if exp.nil? || !exp.boolean?
+        raise "Invalid predicate: %s" % s.rest.inspect 
+      end
+      unless s.scan(/\]/)
+        raise "Invalid predicate: %s" % s.rest.inspect 
+      end
+      Predicate.new(exp)
+    end
+    
+    def self.each_predicate(s)
+      until s.eos?
+        obj = next_predicate(s)
+        break if obj.nil?
+        yield obj
+      end
+    end
+    
+    def self.next_step(s)
+      if s.scan /\.?\/\/([\w*]+)/
+        return Descendant.new(s[1])
+      elsif s.scan /descendant::([\w*]+)/
+        return Descendant.new(s[1])
+      elsif s.scan /child::([\w*]+)/
+        return Child.new(s[1])
+      elsif s.scan /([\w*]+)/
+        return Child.new(s[1])
+      elsif s.scan /.\//
+        return Self.new
+      elsif s.bol? && s.scan(/\//)
+        return Root.new
+      end
+    end
+    
+    def self.each_step(s)
+      until s.eos?
+        obj = next_step(s)
+        break if obj.nil?
+        each_predicate(s) do |p|
+          obj << p
+        end
+        yield obj
+        unless s.match?(/\/\//)
+          s.scan /\//
+        end
+      end
+    end
+      
+  end
+end

data/lib/jpath/parser/formula.rb

@@ -0,0 +1,225 @@
+module JPath
+  module Parser
+    class Predicate
+      
+      attr_reader :expression
+      
+      def initialize(expression)
+        @expression = expression
+      end
+      
+      def true?(*args)
+        expression.true?(*args)
+      end
+      
+      def to_s
+        "[%s]" % expression
+      end
+      
+    end
+    class Operator
+      
+      attr_reader :char
+      
+      attr_reader :parts
+      
+      def initialize(char)
+        @char  = char
+        @parts = []
+      end
+      
+      def boolean?
+        false
+      end
+      
+      def +(other)
+        add(other)
+      end
+      
+      def add(other)
+        @parts << other
+        if parts.size < 2
+          self
+        else
+          Formula.new(char, parts)
+        end
+      end
+      
+      def to_s
+        char.to_s
+      end
+      
+    end
+    class Formula
+      
+      attr_reader :parts
+      
+      attr_reader :type
+      
+      def initialize(type, *parts)
+        @type  = type
+        @parts = parts.flatten
+      end
+      
+      def true?(*args)
+        f = first.value(*args)
+        s = second.value(*args)
+        if requires_boolean?
+          unless f === true or f === false
+            return false
+          end
+          unless s === true or s === false
+            return false
+          end
+        else
+          unless f.is_a?(Numeric)
+            return false
+          end
+          unless s.is_a?(Numeric)
+            return false
+          end
+        end
+        case type
+        when "+"
+          f + s
+        when "-"
+          f - s
+        when "*"
+          f * s
+        when "/"
+          f / s
+        when ">"
+          f > s
+        when "<"
+          f < s
+        when "="
+          f == s
+        when "and"
+          f && s
+        when "or"
+          f || s
+        else
+          raise "Invalid formula type: %s" % type
+        end
+      end
+      
+      def first
+        parts[0]
+      end
+      
+      def second
+        parts[1]
+      end
+      
+      def requires_boolean?
+        %w(and or).include?(type)
+      end
+      
+      def boolean?
+        %w(> < = and or).include?(type)
+      end
+      
+      def to_predicate
+        Predicate.new(self)
+      end
+      
+      def to_s
+        "%s%s%s" % [first, type, second]
+      end
+      
+    end
+    class Contains
+      
+      attr_reader :item
+      
+      def initialize(item)
+        @item = item
+      end
+      
+      def true?(item, context, index, size)
+        item.children(context).map(&:name).include?(@item.name)
+      end
+      
+      def boolean?
+        true
+      end
+      
+      def to_predicate
+        Predicate.new(self)
+      end
+      
+      def to_s
+        item.to_s
+      end
+      
+    end
+    class Position
+      
+      def to_s
+        "position()"
+      end
+      
+      def value(hash, pointer, index, size)
+        index
+      end
+      
+      def +(other)
+        other.add(self)
+      end
+      
+    end
+    class Last
+      
+      def value(hash, pointer, index, size)
+        size
+      end
+      
+      def to_s
+        "last()"
+      end
+      
+    end
+    class Literal
+      
+      attr_reader :string
+      
+      def initialize(string)
+        @string = string
+      end
+      
+      def value(*args)
+        string
+      end
+      
+      def boolean?
+        false
+      end
+      
+      def to_s
+        string.inspect
+      end
+      
+    end
+    class Number
+      
+      attr_reader :number
+      
+      def initialize(number)
+        @number = number
+      end
+      
+      def value(*args)
+        number
+      end
+      
+      def boolean?
+        false
+      end
+      
+      def to_s
+        number.to_s
+      end
+      
+    end
+  end
+end

data/lib/jpath/parser/path.rb

@@ -0,0 +1,53 @@
+module JPath
+  module Parser
+    class Union
+      
+      def initialize(*paths)
+        @paths = paths
+      end
+      
+      def to_s
+        @paths.map(&:to_s).join("|")
+      end
+      
+    end
+    class Path
+      
+      attr_reader :steps
+      
+      def initialize
+        @steps = []
+        if block_given?
+          yield self
+        end
+      end
+      
+      def from(item)
+        unless item.is_a?(Item)
+          item = Item.new(item)
+        end
+        list = [Pointer.new]
+        steps.each do |step|
+          list = list.map { |node|
+            step.from(item, node).to_a
+          }.flatten
+        end
+        list = list.map do |pointer|
+          item[pointer]
+        end
+        list
+      end
+      
+      def <<(step)
+        unless step.is_a?(Self)
+          @steps << step
+        end
+      end
+      
+      def to_s
+        @steps.join("/")
+      end
+    
+    end
+  end
+end

data/lib/jpath/parser/step.rb

@@ -0,0 +1,126 @@
+module JPath
+  module Parser
+    class Step
+      
+      attr_reader :name
+      
+      attr_reader :predicates
+      
+      def initialize(name)
+        @name = name
+        @predicates = []
+      end
+      
+      def wildcard?
+        name == '*'
+      end
+      
+      def +(other)
+        other.add(self)
+      end
+      
+      def <<(predicate)
+        @predicates << predicate
+      end
+      
+      def to_s
+        "%s::%s%s" % [axis, name, predicates.map(&:to_s).join("")]
+      end
+      
+    end
+    class Self < Step
+      
+      def initialize
+        super(nil)
+      end
+
+      def to_s
+        "self"
+      end
+
+    end
+    class Root < Step
+      
+      def initialize
+        super(nil)
+      end
+      
+      def from(item, context)
+        [context]
+      end
+      
+      def to_s
+        ""
+      end
+
+    end
+    class Attribute < Step
+      
+      def boolean?
+        false
+      end
+      
+      def value(item, context, index, size)
+        value = item[context + name]
+        if value.nil?
+          return nil
+        end
+        if value =~ /\A\d+\.\d+\z/
+          value.to_f
+        elsif value =~ /\A\d+\z/
+          value.to_i
+        else
+          value
+        end
+      end
+      
+      def axis
+        "attribute"
+      end
+
+    end
+    class Node < Step
+      
+      def select(item, list)
+        select_by_predicates item, select_by_name(list)
+      end
+      
+      private
+      
+      def select_by_name(list)
+        wildcard? ? list : list.select { |child| child.name == @name }
+      end
+      
+      def select_by_predicates(item, list)
+        predicates.each_with_index { |p| list = select_by_predicate(item, list, p) }; list
+      end
+      
+      def select_by_predicate(item, list, p)
+        list.select.with_index { |context, index| p.true?(item, context, index + 1, list.size) }
+      end
+      
+    end
+    class Child < Node
+      
+      def from(item, context)
+        return select item, item.children(context)
+      end
+      
+      def axis
+        "child"
+      end
+      
+    end
+    class Descendant < Node
+      
+      def from(item, context)
+        return select item, item.descendants(context)
+      end
+      
+      def axis
+        "descendant"
+      end
+      
+    end
+  end
+end

data/lib/jpath/pointer.rb

@@ -0,0 +1,65 @@
+module JPath
+  class Pointer
+    
+    def self.parse(string)
+      new string.split(".").map { |str|
+        str =~ /\A\d+\z/ ? str.to_i : str
+      }.to_a
+    end
+    
+    def initialize(*ary)
+      @ary = ary.flatten
+    end
+    
+    def ==(other)
+      to_s == other.to_s
+    end
+    
+    def +(string)
+      self.class.new(@ary + [string])
+    end
+    
+    def each(&block)
+      @ary.each(&block)
+    end
+    
+    def name
+      index? ? (parent.nil? ? nil : parent.name) : @ary.last
+    end
+    
+    def grandparent
+      parent.nil? ? nil : parent.parent
+    end
+    
+    def parent
+      top? ? nil : self.class.new(without_last)
+    end
+    
+    def size
+      @ary.size
+    end
+    
+    def index?
+      @ary.last.is_a?(Integer)
+    end
+    
+    def top?
+      @ary.empty? or top_index?
+    end
+    
+    def to_s
+      @ary.join(".")
+    end
+    
+    private
+    
+    def top_index?
+      index? && size == 1
+    end
+    
+    def without_last
+      @ary[0...-1]
+    end
+    
+  end
+end

data/spec/item_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe JPath::Item do
+  
+  let(:item) do
+    JPath::Item.new(HASH)
+  end
+  
+  context "#[]" do
+    it "returns smth" do
+      item["store.book.0"].should == HASH["store"]["book"][0]
+    end
+  end
+
+  context "#parent" do
+    it "returns smth" do
+      item.parent("store.book.0").to_s.should == "store"
+    end
+    it "returns smth" do
+      item.parent("store.book.0.title").to_s.should == "store.book.0"
+    end
+  end
+
+  context "#ancestors" do
+    it "returns smth" do
+      item.ancestors("store.book.0").map(&:to_s).should == ["store", ""]
+    end
+    it "returns smth" do
+      item.ancestors("store.book.0.title").map(&:to_s).should == ["store.book.0", "store", ""]
+    end
+  end
+  
+  context "#children" do
+    it "returns smth" do
+      item.children("store").map(&:to_s).should == ["store.book.0", "store.book.1", "store.book.2", "store.book.3", "store.bicycle"]
+    end
+    it "returns smth" do
+      item.children("store.bicycle").map(&:to_s).should == ["store.bicycle.color", "store.bicycle.price"]
+    end
+  end
+
+  context "#attributes" do
+    it "returns smth" do
+      item.attributes("store").map(&:to_s).should == []
+    end
+    it "returns smth" do
+      item.attributes("store.bicycle").map(&:to_s).should == ["store.bicycle.color", "store.bicycle.price"]
+    end
+  end
+  
+  context "#descendants" do
+    it "returns smth" do
+      item.descendants("store.bicycle").map(&:to_s).should == ["store.bicycle.color", "store.bicycle.price"]
+    end
+    it "returns smth" do
+      item.descendants("store").map(&:to_s).should == ["store.book.0", "store.book.0.category", "store.book.0.author", "store.book.0.title", "store.book.0.price", "store.book.1", "store.book.1.category.0", "store.book.1.author", "store.book.1.title", "store.book.1.price", "store.book.2", "store.book.2.category", "store.book.2.author", "store.book.2.title", "store.book.2.isbn", "store.book.2.price", "store.book.3", "store.book.3.category", "store.book.3.author", "store.book.3.title", "store.book.3.isbn", "store.book.3.price", "store.bicycle", "store.bicycle.color", "store.bicycle.price"]
+    end
+  end
+  
+  context "#following" do
+    it "returns smth" do
+      item.following("store.book.0").map(&:to_s).should == ["store.book.1", "store.book.2", "store.book.3", "store.bicycle"]
+    end
+    it "returns smth" do
+      item.following("store.book.0.author").map(&:to_s).should == ["store.book.0.title", "store.book.0.price"]
+    end
+    it "returns smth" do
+      item.following("store.bicycle").map(&:to_s).should == []
+    end
+  end
+
+  context "#preceding" do
+    it "returns smth" do
+      item.preceding("store.book.2").map(&:to_s).should == ["store.book.0", "store.book.1"]
+    end
+    it "returns smth" do
+      item.preceding("store.book.0.author").map(&:to_s).should == ["store.book.0.category"]
+    end
+    it "returns smth" do
+      item.preceding("store.bicycle").map(&:to_s).should == ["store.book.0", "store.book.1", "store.book.2", "store.book.3"]
+    end
+  end
+  
+end

data/spec/jpath_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe JPath do
+  
+  context "/store/book/author" do
+    it "returns the authors of all books in the store" do
+      JPath.find(HASH, "/store/book/author").should == ["Nigel Rees", "Evelyn Waugh", "Herman Melville", "J. R. R. Tolkien"]
+    end
+  end
+
+  context "//author" do
+    it "returns all authors" do
+      JPath.find(HASH, "//author").should == ["Nigel Rees", "Evelyn Waugh", "Herman Melville", "J. R. R. Tolkien"]
+    end
+  end
+  
+  context "/store/*" do
+    it "all things in store, which are some books and a red bicycle" do
+      JPath.find(HASH, "/store/*").should == [HASH["store"]["book"][0], HASH["store"]["book"][1], HASH["store"]["book"][2], HASH["store"]["book"][3], HASH["store"]["bicycle"]]
+    end
+  end
+
+  context "/store//price" do
+    it "returns the price of everything in the store" do
+      JPath.find(HASH, "/store//price").should == [8.95, 12.99, 8.95, 22.99, 19.95]
+    end
+  end
+  
+  context "//book[3]" do
+    it "returns the third book" do
+      JPath.find(HASH, "//book[3]").should == [HASH["store"]["book"][2]]
+    end
+  end
+  
+  context "//book[last()]" do
+    it "the last book in order" do
+      JPath.find(HASH, "//book[last()]").should == [HASH["store"]["book"][3]]
+    end
+  end
+  
+  context "//book[position()<3]" do
+    it "returns the first two books" do
+      JPath.find(HASH, "//book[position()<3]").should == [HASH["store"]["book"][0], HASH["store"]["book"][1]]
+    end
+  end
+  
+  context "//book[isbn]" do
+    it "returns all books with isbn number" do
+      JPath.find(HASH, "//book[isbn]").should == [HASH["store"]["book"][2], HASH["store"]["book"][3]]
+    end
+  end
+  
+  context "//book[@price<10]" do
+    it "returns all books cheapier than 10" do
+      JPath.find(HASH, "//book[@price<10]").should == [HASH["store"]["book"][0], HASH["store"]["book"][2]]
+    end
+  end
+  
+end

data/spec/parser_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe JPath::Parser do
+  
+  it "parses child" do
+    JPath.parse("store").to_s.should               == "child::store"
+    JPath.parse("child::store").to_s.should        == "child::store"
+    JPath.parse("*").to_s.should                   == "child::*"
+    JPath.parse("./store").to_s.should             == "child::store"
+    JPath.parse("/store").to_s.should              == "/child::store"
+    JPath.parse("/child::store").to_s.should       == "/child::store"
+    JPath.parse("/*").to_s.should                  == "/child::*"
+    JPath.parse("/store/book").to_s.should         == "/child::store/child::book"
+  end
+  
+  it "parses descendant" do
+    JPath.parse("//book").to_s.should              == "descendant::book"
+    JPath.parse("descendant::book").to_s.should    == "descendant::book"
+    JPath.parse("//*").to_s.should                 == "descendant::*"
+    JPath.parse(".//book").to_s.should             == "descendant::book"
+    JPath.parse("/descendant::book").to_s.should   == "/descendant::book"
+    JPath.parse("/*").to_s.should                  == "/child::*"
+    JPath.parse("/store//price").to_s.should       == "/child::store/descendant::price"
+  end
+  
+  it "parses attributes" do
+    JPath.parse('book[1]').to_s.should             == 'child::book[position()=1]'
+    JPath.parse('book[last()]').to_s.should        == 'child::book[position()=last()]'
+    JPath.parse('book[position()>1]').to_s.should  == 'child::book[position()>1]'
+    JPath.parse('book[@price]').to_s.should        == 'child::book[attribute::price]'
+    JPath.parse('book[@price="8.95"]').to_s.should == 'child::book[attribute::price="8.95"]'
+    JPath.parse('book[@price=8.95]').to_s.should   == 'child::book[attribute::price=8.95]'
+    JPath.parse('book[@price<8.95]').to_s.should   == 'child::book[attribute::price<8.95]'
+  end
+  
+end

data/spec/pointer_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe JPath::Pointer do
+  
+  context ".parse" do
+    it "returns Pointer" do
+      JPath::Pointer.parse("store.book.0.title").to_s.should == 'store.book.0.title'
+    end
+    it "returns Pointer" do
+      JPath::Pointer.parse("").to_s.should == ''
+    end
+  end
+  
+  context "#index?" do
+    it "returns false" do
+      JPath::Pointer.new().should_not be_index
+    end
+    it "returns false" do
+      JPath::Pointer.new("store", "book", 0, "title").should_not be_index
+    end
+    it "returns true" do
+      JPath::Pointer.new(0).should be_index
+    end
+    it "returns true" do
+      JPath::Pointer.new("store", "book", 0).should be_index
+    end
+  end
+
+  context "#name" do
+    it "returns nil" do
+      JPath::Pointer.new().name.should be_nil
+    end
+    it "returns name" do
+      JPath::Pointer.new("store", "book", 0, "title").name.should == 'title'
+    end
+    it "returns true" do
+      JPath::Pointer.new("store", "book").name.should == 'book'
+    end
+  end
+  
+  context "#top?" do
+    it "returns true" do
+      JPath::Pointer.new().should be_top
+    end
+    it "returns true" do
+      JPath::Pointer.new(0).should be_top
+    end
+    it "returns false" do
+      JPath::Pointer.new("store").should_not be_top
+    end
+  end
+  
+  context "#parent" do
+    it "returns nil" do
+      JPath::Pointer.new(0).parent.should be_nil
+    end
+    it "returns root" do
+      JPath::Pointer.new("store").parent.to_s.should == ""
+    end
+    it "returns root" do
+      JPath::Pointer.new("store", "0").parent.to_s.should == 'store'
+    end
+  end
+
+  context "#grandparent" do
+    it "returns nil" do
+      JPath::Pointer.new(0).grandparent.should be_nil
+    end
+    it "returns nil" do
+      JPath::Pointer.new("store").grandparent.should be_nil
+    end
+    it "returns root" do
+      JPath::Pointer.new("store", "0").grandparent.to_s.should == ""
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+require 'jpath'
+
+HASH = {
+  "store" => {
+    "book" => [{
+      "category" => "reference",
+      "author" => "Nigel Rees",
+      "title" => "Sayings of the Century",
+      "price" => 8.95
+    }, {
+      "category" => ["fiction"],
+      "author" => "Evelyn Waugh",
+      "title" => "Sword of Honour",
+      "price" => 12.99
+    }, {
+      "category" => "fiction",
+      "author" => "Herman Melville",
+      "title" => "Moby Dick",
+      "isbn" => "0-553-21311-3",
+      "price" => 8.95
+    }, {
+      "category" => "fiction",
+      "author" => "J. R. R. Tolkien",
+      "title" => "The Lord of the Rings",
+      "isbn" => "0-395-19395-8",
+      "price" => 22.99
+    }],
+    "bicycle" => {
+      "color" => "red",
+      "price" => 19.95
+    }
+  }
+}

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: jpath
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Alex Serebryakov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: JPath is a Ruby library that allows to execute XPath queries on JSON
+  documents
+email:
+- alex@merimond.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/jpath/item.rb
+- lib/jpath/parser/formula.rb
+- lib/jpath/parser/path.rb
+- lib/jpath/parser/step.rb
+- lib/jpath/parser.rb
+- lib/jpath/pointer.rb
+- lib/jpath.rb
+- Rakefile
+- README.md
+- LICENSE
+- spec/item_spec.rb
+- spec/jpath_spec.rb
+- spec/parser_spec.rb
+- spec/pointer_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/merimond/jpath
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: jpath
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: XPath queries for JSON documents
+test_files:
+- spec/item_spec.rb
+- spec/jpath_spec.rb
+- spec/parser_spec.rb
+- spec/pointer_spec.rb
+- spec/spec_helper.rb