ldpath 0.1.0 → 0.2.0

data/.rubocop_todo.yml

@@ -0,0 +1,36 @@
+# This configuration was generated by `rubocop --auto-gen-config`
+# on 2015-05-03 18:22:33 -0700 using RuboCop version 0.30.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 1
+# Cop supports --auto-correct.
+Lint/UnusedBlockArgument:
+  Enabled: false
+
+# Offense count: 68
+# Cop supports --auto-correct.
+Lint/UnusedMethodArgument:
+  Enabled: false
+
+# Offense count: 4
+Metrics/AbcSize:
+  Max: 28
+
+# Offense count: 47
+# Configuration parameters: AllowURI, URISchemes.
+Metrics/LineLength:
+  Max: 171
+
+# Offense count: 7
+# Cop supports --auto-correct.
+Style/ExtraSpacing:
+  Enabled: false
+
+# Offense count: 42
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle, SupportedStyles.
+Style/StringLiterals:
+  Enabled: false

data/Gemfile

@@ -2,4 +2,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in ldpath.gemspec
 gemspec
-

data/Rakefile

@@ -3,4 +3,4 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/bin/ldpath

@@ -6,8 +6,8 @@ require 'ldpath'
 require 'byebug'
 
 begin
-require 'rest-client'
-rescue LoadError
+  require 'rest-client'
+  rescue LoadError
 end
 
 options = {}
@@ -15,7 +15,7 @@ OptionParser.new do |opts|
   opts.banner = "Usage: ldpath [options] URI"
 
   opts.on("--program=STRING_URI_OR_FILE", "LDPath program to run (- for STDIN)") do |program|
-    if File.exists? program or program =~ /^http/
+    if File.exists?(program) || program =~ /^http/
       options[:program] = open(program).read
     elsif program.strip == "-"
       options[:program] = $stdin.read

data/lib/ldpath.rb

@@ -10,9 +10,9 @@ module Ldpath
   require 'ldpath/transform'
   require 'ldpath/functions'
   require 'ldpath/program'
-  
+
   class << self
-    def evaluate program, uri, context
+    def evaluate(program, uri, context)
       Ldpath::Program.parse(program).evaluate(uri, context)
     end
 
@@ -26,7 +26,7 @@ module Ldpath
       end
     end
 
-    def logger= logger
+    def logger=(logger)
       @logger = logger
     end
   end

data/lib/ldpath/field_mapping.rb

@@ -1,2 +1 @@
-class Ldpath::FieldMapping < Struct.new(:name, :selector, :field_type)
-end
+Ldpath::FieldMapping = Struct.new(:name, :selector, :field_type)

data/lib/ldpath/functions.rb

@@ -1,180 +1,187 @@
+# rubocop:disable Style/MethodName
 module Ldpath
   module Functions
-    def concat uri, context, *args
+    def concat(uri, context, *args)
       args.flatten.compact.join
     end
-    
-    def first uri, context, *args
+
+    def first(uri, context, *args)
       args.flatten.compact.first
     end
-    
-    def last uri, context, *args
+
+    def last(uri, context, *args)
       args.flatten.compact.last
     end
 
-    def count uri, context, *args
+    def count(uri, context, *args)
       args.flatten.compact.length
     end
-    
-    def eq uri, context, *args
+
+    def eq(uri, context, *args)
       a, b, *rem = args.flatten
       unless rem.empty?
         raise "Too many arguments to fn:eq"
       end
       a == b
     end
-    
-    def ne uri, context, *args
+
+    def ne(uri, context, *args)
       a, b, *rem = args.flatten
       unless rem.empty?
         raise "Too many arguments to fn:ne"
       end
       a != b
     end
-    
-    def lt uri, context, *args
+
+    def lt(uri, context, *args)
       a, b, *rem = args.flatten
       unless rem.empty?
         raise "Too many arguments to fn:lt"
       end
       a < b
     end
-    
-    def le uri, context, *args
+
+    def le(uri, context, *args)
       a, b, *rem = args.flatten
       unless rem.empty?
         raise "Too many arguments to fn:le"
       end
       a <= b
     end
-    
-    def gt uri, context, *args
+
+    def gt(uri, context, *args)
       a, b, *rem = args.flatten
       unless rem.empty?
         raise "Too many arguments to fn:gt"
       end
       a > b
     end
-    
-    def ge uri, context, *args
+
+    def ge(uri, context, *args)
       a, b, *rem = args.flatten
       unless rem.empty?
         raise "Too many arguments to fn:ge"
       end
       a >= b
     end
-    
+
     # collections
-    def flatten uri, context, *args
-      
+    def flatten(uri, context, lists)
+      Array(lists).flatten.map { |x| RDF::List.new(x, context).to_a }.flatten
     end
-    
-    def get uri, context, *args
+
+    def get(uri, context, list, idx)
+      flatten(uri, context, list)[idx.to_i]
     end
-    
-    def subList uri, context, *args
-      
+
+    def subList(uri, context, list, idx_start, idx_end = nil)
+      arr = flatten(uri, context, list)
+
+      if idx_end
+        arr[(idx_start.to_i..(idx_end.to_i - idx_start.to_i))]
+      else
+        arr.drop(idx_start.to_i)
+      end
     end
-    
+
     # dates
-    
-    def earliest uri, context, *args
+
+    def earliest(uri, context, *args)
       args.flatten.min
     end
-    
-    def latest uri, context, *args
+
+    def latest(uri, context, *args)
       args.flatten.max
     end
-    
+
     # math
-    
-    def min uri, context, *args
+
+    def min(uri, context, *args)
       args.flatten.min
     end
-    
-    def max uri, context, *args
+
+    def max(uri, context, *args)
       args.flatten.max
     end
-    
-    def round uri, context, *args
-      args.map do |n| 
+
+    def round(uri, context, *args)
+      args.map do |n|
         Array(n).map do |i|
           i.respond_to? :round ? i.round : i
         end
       end
     end
-    
-    def sum uri, context, *args
+
+    def sum(uri, context, *args)
       args.inject(0) { |sum, n| sum + n }
     end
-    
+
     # text
-    
-    def replace uri, context, str, pattern, replacement
+
+    def replace(uri, context, str, pattern, replacement)
       regex = Regexp.parse(pattern)
       Array(str).map do |x|
         x.gsub(regex, replacement)
       end
     end
-    
-    def strlen uri, context, str
-      Array(str).map { |x| x.length }
+
+    def strlen(uri, context, str)
+      Array(str).map(&:length)
     end
-    
-    def wc uri, context, str
+
+    def wc(uri, context, str)
       Array(str).map { |x| x.split.length }
     end
-    
-    def strLeft uri, context, str, left
+
+    def strLeft(uri, context, str, left)
       Array(str).map { |x| x[0..left.to_i] }
     end
-    
-    def strRight uri, context, str, right
+
+    def strRight(uri, context, str, right)
       Array(str).map { |x| x[right.to_i..x.length] }
     end
-    
-    def substr uri, context, str, left, right
+
+    def substr(uri, context, str, left, right)
       Array(str).map { |x| x[left.to_i..right.to_i] }
     end
-    
-    def strJoin uri, context, str, sep = "", prefix = "", suffix = ""
+
+    def strJoin(uri, context, str, sep = "", prefix = "", suffix = "")
       prefix + Array(str).join(sep) + suffix
     end
-    
-    def equals uri, context, str, other
+
+    def equals(uri, context, str, other)
       Array(str).map { |x| x == other }
     end
-    
-    def equalsIgnoreCase uri, context, str, other
+
+    def equalsIgnoreCase(uri, context, str, other)
       Array(str).map { |x| x.downcase == other.downcase }
     end
-    
-    def contains uri, context, str, substr
+
+    def contains(uri, context, str, substr)
       Array(str).map { |x| x.include? substr }
     end
-    
-    def startsWith uri, context, str, suffix
+
+    def startsWith(uri, context, str, suffix)
       Array(str).map { |x| x.start_with? suffix }
     end
-    
-    def endsWith uri, context, str, suffix
+
+    def endsWith(uri, context, str, suffix)
       Array(str).map { |x| x.end_with? suffix }
     end
-    
-    def isEmpty uri, context, str
+
+    def isEmpty(uri, context, str)
       Array(str).map(&:empty?)
     end
 
-    def predicates uri, context, *args
+    def predicates(uri, context, *args)
       context.query([uri, nil, nil]).map(&:predicate).uniq
     end
 
-    def xpath uri, context, xpath, node
+    def xpath(uri, context, xpath, node)
       x = Array(xpath).flatten.first
       Array(node).flatten.compact.map do |n|
-        Nokogiri::XML(n).xpath(x, prefixes.map { |k,v| [k, v.to_s] }).map(&:text)
+        Nokogiri::XML(n).xpath(x, prefixes.map { |k, v| [k, v.to_s] }).map(&:text)
       end
     end
-  
   end
 end

data/lib/ldpath/parser.rb

@@ -2,36 +2,64 @@ require 'parslet'
 
 module Ldpath
   class Parser < Parslet::Parser
-    root :lines
-    rule(:lines) { line.repeat }
-    rule(:line) { ((wsp >> expression) | expression) >> space_not_newline? >> (newline | eof) }
+    root :doc
+    rule(:doc) { prologue? >> statements? >> eof }
 
-    rule(:newline) {  (str("\n") >> str("\r").maybe).repeat(1) }
-    rule(:eof) { any.absent? }
+    rule(:prologue) { wsp? >> directive?.repeat(1, 1) >> (eol >> wsp? >> directive >> wsp?).repeat >> wsp? >> eol? }
+    rule(:prologue?) { prologue.maybe }
+    rule(:directive) { prefixID | graph | filter | boost }
+    rule(:directive?) { directive.maybe }
 
-    rule(:space) { match('\s').repeat(1) }
-    rule(:spaces?) { space.maybe }
-    rule(:space_not_newline) { str("\n").absent? >> space }
-    rule(:space_not_newline?) { space_not_newline.maybe }
+    rule(:statements) { wsp? >> statement?.repeat(1, 1) >> (eol >> wsp? >> statement >> wsp?).repeat >> wsp? >> eol? }
+    rule(:statements?) { statements.maybe }
+    rule(:statement) { mapping }
+    rule(:statement?) { mapping.maybe }
 
-    rule(:wsp) { (space | multiline_comment).repeat(1) }
+    # whitespace rules
+    rule(:eol) { (str("\n") >> str("\r").maybe).repeat(1) }
+    rule(:eol?) { eol.maybe }
+    rule(:eof) { any.absent? }
+    rule(:space) { str("\n").absent? >> match('\s').repeat(1) }
+    rule(:space?) { space.maybe }
+    rule(:wsp) { (space | multiline_comment | single_line_comment).repeat(1) }
     rule(:wsp?) { wsp.maybe }
-    rule(:multiline_comment) { (str('/*') >> (str('*/').absent? >> any).repeat >> str('*/') ) }
+    rule(:multiline_comment) { (str("/*") >> (str("*/").absent? >> any).repeat >> str("*/")) }
+    rule(:single_line_comment) { str("#") >> (eol.absent? >> any).repeat }
 
-    rule(:expression) { wsp | namespace | mapping | graph | filter | boost }
-    
-    rule(:int) { match("\\d+") }
-    
-    rule(:comma) { str(",") }
-    rule(:scolon) { str(";") }
-    rule(:colon) { str(":") }
-    rule(:dcolon) { str("::") }
-    rule(:assign) { str("=") }
-    rule(:k_prefix) { str("@prefix")}
-    rule(:k_graph) { str("@graph")}
-    rule(:k_filter) { str("@filter")}
-    rule(:k_boost) { str("@boost")}
-    
+    # simple types
+    rule(:integer) { match("[+-]").maybe >> match("\\d+") }
+    rule(:decimal) { match("[+-]").maybe >> match("\\d*") >> str(".") >> match("\\d+") }
+    rule(:double) do
+      match("[+-]").maybe >> (
+        (match("\\d+") >> str('.') >> match("\\d*") >> exponent) |
+        (str('.') >> match("\\d+") >> exponent) |
+        (match("\\d+") >> exponent)
+      )
+    end
+
+    rule(:exponent) { match('[Ee]') >> match("[+-]").maybe >> match("\\d+") }
+    rule(:numeric_literal) { integer | decimal | double }
+    rule(:boolean_literal) { str('true') | str('false') }
+
+    rule(:string) { string_literal_quote | string_literal_single_quote | string_literal_long_single_quote | string_literal_long_quote }
+
+    rule(:string_literal_quote) do
+      str('"') >> (match("[^\\\"\\\\\\r\\n]") | echar | uchar).repeat.as(:literal) >> str('"')
+    end
+
+    rule(:string_literal_single_quote) do
+      str("'") >> (match("[^'\\\\\\r\\n]") | echar | uchar).repeat.as(:literal) >> str("'")
+    end
+
+    rule(:string_literal_long_quote) do
+      str('"""') >> (str('"""').absent? >> match("[^\\\\]") | echar | uchar).repeat.as(:literal) >> str('"""')
+    end
+
+    rule(:string_literal_long_single_quote) do
+      str("'''") >> (str("'''").absent? >> match("[^\\\\]") | echar | uchar).repeat.as(:literal) >> str("'''")
+    end
+
+    # operators
     rule(:self_op) { str(".") }
     rule(:and_op) { str("&") }
     rule(:or_op) { str("|") }
@@ -40,337 +68,374 @@ module Ldpath
     rule(:star) { str("*") }
     rule(:not_op) { str("!") }
     rule(:inverse) { str("^") }
-    rule(:tap) { str("?") }
+    rule(:question) { str("?") }
     rule(:is) { str "is" }
     rule(:is_a) { str "is-a" }
-    rule(:func) { str "fn:"}
+    rule(:func) { str "fn:" }
     rule(:type) { str "^^" }
     rule(:lang) { str "@" }
     rule(:loose) { str("~") }
-    
-    # todo: fixme
-    rule(:uri) do
-      uri_in_brackets | 
-      prefix_and_localname
+
+    # strings
+    rule(:comma) { str(",") }
+    rule(:scolon) { str(";") }
+    rule(:colon) { str(":") }
+    rule(:dcolon) { str("::") }
+    rule(:assign) { str("=") }
+    rule(:k_prefix) { str("@prefix") }
+    rule(:k_graph) { str("@graph") }
+    rule(:k_filter) { str("@filter") }
+    rule(:k_boost) { str("@boost") }
+
+    # iris
+    rule(:iri) do
+      iriref |
+        prefixed_name
+    end
+
+    rule(:iriref) do
+      str("<") >> (match("[^[[:cntrl:]]<>\"{}|^`\\\\]") | uchar).repeat.as(:iri) >> str('>')
+    end
+
+    rule(:uchar) do
+      str('\u') >> hex.repeat(4, 4) | hex.repeat(6, 6)
+    end
+
+    rule(:echar) do
+      str('\\') >> match("[tbnrf\"'\\\\]")
+    end
+
+    rule(:hex) do
+      match("[[:xdigit:]]")
+    end
+
+    rule(:prefixed_name) do
+      (identifier.as(:prefix) >> str(":") >> identifier.as(:localName)).as(:iri)
     end
-    
-    rule(:uri_in_brackets) do
-      str("<") >> (str(">").absent? >> any).repeat.as(:uri) >> str(">")
+
+    rule(:identifier) { pn_chars_base >> (str(".").maybe >> pn_chars).repeat }
+
+    rule(:pn_chars_base) do
+      # also \u10000-\uEFFFF
+      match("[A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]")
     end
-    
-    rule(:prefix_and_localname) do
-      (identifier.as(:prefix) >> str(":") >> identifier.as(:localName)).as(:uri)
+
+    rule(:pn_chars) do
+      pn_chars_base | match("[0-9\u00B7\u0300-\u036F\u203F-\u2040_-]")
     end
-    
-    rule(:identifier) { match["a-zA-Z0-9_"] >> (match["a-zA-Z0-9_'\\.-"]).repeat }
 
-    rule(:strlit) {
-      str('"') >> (str("\\") >> str("\"") | (str('"').absent? >> any)).repeat.as(:literal) >> str('"')
-    }
+    # "xyz"; 0.123e52; true
+    rule(:literal) do
+      rdf_literal | numeric_literal | boolean_literal
+    end
 
-    rule(:node) {
-      uri.as(:uri) | strlit.as(:literal)
-    }
+    # "xyz"; "xyz"^^a; "xyz"@en
+    rule(:rdf_literal) do
+      string >> (literal_language_test | literal_type_test).maybe
+    end
+
+    rule(:node) do
+      iri.as(:iri) | literal.as(:literal)
+    end
 
-    # @prefix id = uri ;
-    rule(:namespace) { 
+    # @prefix id = iri ;
+    rule(:prefixID) do
       (
       k_prefix >> wsp? >>
-      identifier.as(:id) >> wsp? >>
+      (identifier | str("")).as(:id) >> wsp? >>
       colon >> wsp? >>
-      uri.as(:uri) >> space_not_newline? >> scolon.maybe
-      ).as(:namespace)
-    }
-    
-    # @graph uri, uri, uri ;
-    rule(:graph) {
-      k_graph >> wsp? >> 
-      uri_list.as(:graphs) >> wsp? >> scolon
-    }
-    
-    rule(:uri_list) {
-      uri.as(:uri) >>
-      (
-        wsp? >> 
-        comma >> wsp? >> 
-        uri_list.as(:rest)
-      ).repeat
-    }
+      iriref >> space? >> scolon.maybe
+      ).as(:prefixID)
+    end
+
+    # @graph iri, iri, iri ;
+    rule(:graph) do
+      k_graph >> wsp? >>
+        iri_list.as(:graphs) >> wsp? >> scolon
+    end
+
+    # <info:a>, <info:b>
+    rule(:iri_list) do
+      iri.as(:iri) >>
+        (
+          wsp? >>
+          comma >> wsp? >>
+          iri_list.as(:rest)
+        ).repeat
+    end
 
     # @filter test ;
-    rule(:filter) {
+    rule(:filter) do
       (k_filter >> wsp? >> node_test.as(:test) >> wsp? >> scolon).as(:filter)
-    }
+    end
 
     # @boost selector ;
-    rule(:boost) {
+    rule(:boost) do
       (k_boost >> wsp? >> selector.as(:selector) >> wsp? >> scolon).as(:boost)
-    }
-    
+    end
+
     # id = . ;
-    rule(:mapping) {
+    rule(:mapping) do
       (
-        (uri_in_brackets | prefix_and_localname | identifier).as(:name) >> wsp? >>
+        label.as(:name) >> wsp? >>
         assign >> wsp? >>
         selector.as(:selector) >>
-        ( wsp? >> 
+        (wsp? >>
           dcolon >> wsp? >> field_type
         ).maybe >> wsp? >> scolon
       ).as(:mapping)
-    }
+    end
 
-    rule(:field_type) {
-      uri.as(:field_type) >> field_type_options.maybe
-    }
+    rule(:label) do
+      iri | identifier
+    end
 
-    rule(:field_type_options) {
+    # xsd:string
+    rule(:field_type) do
+      iri.as(:field_type) >> field_type_options.maybe
+    end
+
+    # ( x = "xyz", y = "abc" )
+    rule(:field_type_options) do
       str("(") >> wsp? >> (field_type_option >> (wsp? >> comma >> wsp? >> field_type_option).repeat).as(:options) >> wsp? >> str(")")
-    }
+    end
+
+    # x = "xyz"
+    rule(:field_type_option) do
+      identifier.as(:key) >> wsp? >> assign >> wsp? >> literal.as(:value)
+    end
 
-    rule(:field_type_option) {
-      identifier.as(:key) >> wsp? >> assign >> wsp? >> strlit.as(:value)
-    }
-    
     # selector groups
-    rule(:selector) {
+    rule(:selector) do
       (
-        compound_selector |
+        compound_or_path_selector |
         testing_selector |
         atomic_selector
       )
-    }
+    end
 
-    rule(:compound_selector) {
-      (
-        union_selector |
-        intersection_selector |
-        path_selector
-      )
-    }
-    
-    rule(:testing_selector) {
+    # &; |
+    rule(:compound_operator) { and_op | or_op }
+
+    # a & b; a | b; a / b
+    rule(:compound_or_path_selector) do
+      path_selector | compound_selector
+    end
+
+    # a & b; a | b
+    rule(:compound_selector) do
+      atomic_or_testing_or_path_selector.as(:left) >> wsp? >>
+        compound_operator.as(:op) >> wsp? >>
+        selector.as(:right)
+    end
+
+    # a / b
+    rule(:path_selector) do
+      atomic_or_testing_selector.as(:left) >> wsp? >>
+        p_sep.as(:op) >> wsp? >>
+        atomic_or_testing_or_path_selector.as(:right)
+    end
+
+    # info:a[is-a z]
+    rule(:testing_selector) do
       atomic_selector.as(:delegate) >>
-      str("[") >> wsp? >>
-      node_test.as(:test) >> wsp? >>
-      str("]")
-    }
+        str("[") >> wsp? >>
+        node_test.as(:test) >> wsp? >>
+        str("]")
+    end
 
-    rule(:atomic_selector) {
+    rule(:atomic_selector) do
       (
         self_selector |
         function_selector |
         property_selector |
         loose_property_selector |
-        wildcard_selector | 
+        wildcard_selector |
         reverse_property_selector |
         string_constant_selector |
         recursive_path_selector |
         grouped_selector |
         tap_selector
       )
-    }    
-
+    end
 
-    rule(:atomic_or_testing_selector) {
+    rule(:atomic_or_testing_selector) do
       (testing_selector | atomic_selector)
-    }
+    end
 
-    rule(:atomic_or_testing_or_path_selector) {
+    rule(:atomic_or_testing_or_path_selector) do
       (path_selector | atomic_or_testing_selector)
-    }
-
-    # Compound selectors
-    ## x / y
-    rule(:path_selector) {
-      (
-        atomic_or_testing_selector.as(:left) >> wsp? >>
-        p_sep >> wsp? >>
-        atomic_or_testing_or_path_selector.as(:right)
-      ).as(:path)
-    }
-    
-    ## x & y
-    rule(:intersection_selector) {
-      (
-        atomic_or_testing_or_path_selector.as(:left) >> wsp? >>
-        and_op >> wsp? >>
-        selector.as(:right)
-      ).as(:intersection)
-    }
-    
-    ## x | y
-    rule(:union_selector) {
-      (
-        atomic_or_testing_or_path_selector.as(:left) >> wsp? >>
-        or_op >> wsp? >>
-        selector.as(:right)
-      ).as(:union)
-    }
+    end
 
     # Atomic Selectors
-    rule(:self_selector) {
+    rule(:self_selector) do
       self_op.as(:self)
-    }
-    
+    end
+
     # fn:x() or fn:x(1,2,3)
-    rule(:function_selector) {
-      func >> identifier.as(:fname) >> str("()") |
+    rule(:function_selector) do
+      function_without_args | function_with_arglist
+    end
+
+    rule(:function_without_args) do
+      func >> identifier.as(:fname) >> str("()")
+    end
+
+    rule(:function_with_arglist) do
       func >> identifier.as(:fname) >> str("(") >> wsp? >> arglist.as(:arglist) >> wsp? >> str(")")
-    }
-    
-    rule(:arglist) {
-      selector >> 
-      (
-        wsp? >> 
-        comma >> wsp? >> 
-        selector
-      ).repeat
-    }
-    
+    end
+
+    rule(:arglist) do
+      selector >>
+        (
+          wsp? >>
+          comma >> wsp? >>
+          selector
+        ).repeat
+    end
+
     # xyz
-    rule(:loose_property_selector) {
-      loose >> 
-      wsp? >> 
-      uri.as(:loose_property)
-    }
+    rule(:loose_property_selector) do
+      loose.as(:loose) >>
+        wsp? >>
+        iri.as(:property)
+    end
 
     # xyz
-    rule(:property_selector) {
-      uri.as(:property)
-    }
+    rule(:property_selector) do
+      iri.as(:property)
+    end
 
     # *
-    rule(:wildcard_selector) {
+    rule(:wildcard_selector) do
       star.as(:wildcard)
-    }
+    end
 
     # ^xyz
-    rule(:reverse_property_selector) {
-      inverse >> uri.as(:reverse_property)
-    }
-    
-    rule(:string_constant_selector) {
-      strlit
-    }
-    
-    # (x)*
-    rule(:recursive_path_selector) {
-      (
-        str("(") >> wsp? >>
-        selector.as(:delegate) >> wsp? >> 
+    rule(:reverse_property_selector) do
+      inverse.as(:reverse) >> iri.as(:property)
+    end
+
+    rule(:string_constant_selector) do
+      string
+    end
+
+    # (x)?; (x)*; (x)+; (x){3,5}
+    rule(:recursive_path_selector) do
+      str("(") >> wsp? >>
+        selector.as(:delegate) >> wsp? >>
         str(")") >>
-        (
-          star |
-          plus |
-          (str("{") >> wsp? >> int.as(:min).maybe >> wsp? >>str(",") >> wsp? >> int.as(:max).maybe >> wsp? >>str("}") ).as(:range)
-        ).as(:repeat)
-      ).as(:recursive)
-    }
-    
-    rule(:grouped_selector) {
-      str("(") >> wsp? >> 
-      selector >> wsp? >> 
-      str(")")
-    }
-
-    rule(:tap_selector) {
-      tap >>
-      str("<") >> wsp? >>
-      identifier.as(:identifier) >> wsp? >>
-      str(">") >> wsp? >>
-      (atomic_selector).as(:tap)
-    }
-    
+        range.as(:repeat)
+    end
+
+    # ?; *; +; {3,5}; {,5}; {3,}
+    rule(:range) do
+      (
+        star |
+        plus |
+        question |
+        str("{") >> wsp? >> integer.as(:min).maybe >> wsp? >> str(",") >> wsp? >> integer.as(:max).maybe >> wsp? >> str("}")
+      ).as(:range)
+    end
+
+    # (<info:a>)
+    rule(:grouped_selector) do
+      str("(") >> wsp? >>
+        selector >> wsp? >>
+        str(")")
+    end
+
+    # ?<a>(<info:a>)
+    rule(:tap_selector) do
+      question >>
+        str("<") >> wsp? >>
+        identifier.as(:identifier) >> wsp? >>
+        str(">") >> wsp? >>
+        (atomic_selector).as(:tap)
+    end
+
     # Testing Selectors
-    
-    rule(:node_test) {
+
+    rule(:node_test) do
       grouped_test |
-      not_test |
-      and_test |
-      or_test  |
-      atomic_node_test
-    }
+        not_test |
+        and_test |
+        or_test |
+        atomic_node_test
+    end
 
-    rule(:atomic_node_test) {
+    rule(:atomic_node_test) do
       literal_language_test |
-      literal_type_test |
-      is_a_test |
-      path_equality_test |
-      function_test |
-      path_test
-    }
-
-    rule(:grouped_test) {
-      str("(")  >> wsp? >> 
-      node_test >> wsp? >> 
-      str(")") 
-    }
-    
-    rule(:not_test) {
+        literal_type_test |
+        is_a_test |
+        path_equality_test |
+        function_test |
+        path_test
+    end
+
+    rule(:grouped_test) do
+      str("(") >> wsp? >>
+        node_test >> wsp? >>
+        str(")")
+    end
+
+    rule(:not_test) do
       (
         not_op >> node_test.as(:delegate)
       ).as(:not)
-    }
-    
-    rule(:and_test) {
+    end
+
+    rule(:and_test) do
       (
-        atomic_node_test.as(:left) >> wsp? >> 
-        and_op >> wsp? >> 
+        atomic_node_test.as(:left) >> wsp? >>
+        and_op >> wsp? >>
         node_test.as(:right)
       ).as(:and)
-    }
-    
-    rule(:or_test) {
+    end
+
+    rule(:or_test) do
       (
-        atomic_node_test.as(:left) >> wsp? >> 
-        or_op >> wsp? >> 
+        atomic_node_test.as(:left) >> wsp? >>
+        or_op >> wsp? >>
         node_test.as(:right)
       ).as(:or)
-    }
+    end
 
     # @en
-    rule(:literal_language_test) {
+    rule(:literal_language_test) do
       lang >> identifier.as(:lang)
-    }
-    
+    end
+
     # ^^xyz
-    rule(:literal_type_test) {
-      type >> uri.as(:type)
-    }
-    
-    rule(:is_a_test) {
+    rule(:literal_type_test) do
+      type >> iri.as(:type)
+    end
+
+    rule(:is_a_test) do
       (
-        is_a >> wsp? >> 
+        is_a >> wsp? >>
         node.as(:right)
       ).as(:is_a)
-    }
-    
-    rule(:path_equality_test) {
+    end
+
+    rule(:path_equality_test) do
       (
         selector >> wsp? >>
         is >> wsp? >>
         node.as(:right)
       ).as(:is)
-    }
-    
-    rule(:function_test) {
-      (
-      func >> identifier.as(:fname) >> str("()") |
-      func >> identifier.as(:fname) >> str("(") >>
-        wsp? >> 
-          arglist.as(:arglist) >>
-        wsp? >> 
-      str(")")
-      )
-    }
+    end
 
-    rule(:path_test) {
+    rule(:function_test) do
+      function_without_args | function_with_arglist
+    end
+
+    rule(:path_test) do
       (
         path_selector |
         testing_selector |
         atomic_selector
       )
-    }
-
+    end
   end
 end