ldpath 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: feb1911da55e6e56d33cb8bccea249060b59f7da
-  data.tar.gz: 87eab8d2813362a18c9ff45707325542f45ec657
+  metadata.gz: 76772761e5cb85b3f0d16df78e8673524dd4849b
+  data.tar.gz: 292da39f546dd6151e6754a060ffadf9464df44d
 SHA512:
-  metadata.gz: 111dbf2d32a03ab3199d622f1ea78c94322a24733e0120c537ed43d2f42c592e650ab72e67f067cf6578d4be2ddcdbfd6756d09369c2e9d8c1fb7757f7624bb2
-  data.tar.gz: 5dc5e8488936d2d14114522cb1880a05e165edc317b6a433b247dff8e235af989419a7fac28b71a8f5741da7a8d0b2b33c3e6d10179a0a3b830461ff748a970e
+  metadata.gz: 536f06a5bb004c85e76ff303cc39cb27204bb853126eb18049e98d9b5bd64e16aa477cc1b1be8314f0ea199fdbd0c186f2b89fb150c3aa45f3e293c339c1c949
+  data.tar.gz: a3914cc93b8b07c9086ecaac7d8a12502cbcb5dfd4a02dd916163ccd92bc8e740176a5379ecc3ddb5904eeb01318f80359dc178673f18a4f838d5a7a6eef6447

data/README.md

@@ -37,7 +37,7 @@ output = program.evaluate uri, context
  
 ## Contributing
 
-1. Fork it ( http://github.com/<my-github-username>/ldpath/fork )
+1. Fork it ( http://github.com/cbeer/ldpath.rb/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/bin/ldpath

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'open-uri'
+require 'ldpath'
+require 'byebug'
+
+begin
+require 'rest-client'
+rescue LoadError
+end
+
+options = {}
+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/
+      options[:program] = open(program).read
+    elsif program.strip == "-"
+      options[:program] = $stdin.read
+    else
+      options[:program] = program
+    end
+  end
+end.parse!
+
+uri = ARGV.shift
+
+puts Ldpath::Program.parse(options[:program]).evaluate(RDF::URI.new(uri)).to_json

data/ldpath.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Chris Beer"]
   spec.email         = ["cabeer@stanford.edu"]
   spec.summary       = %q{Ruby implementation of LDPath}
-  spec.homepage      = "http://github.com/cbeer"
+  spec.homepage      = "https://github.com/cbeer/ldpath.rb"
   spec.license       = "Apache 2"
 
   spec.files         = `git ls-files -z`.split("\x0")

data/lib/ldpath/functions.rb

@@ -1,7 +1,7 @@
 module Ldpath
   module Functions
     def concat uri, context, *args
-      args.join
+      args.flatten.compact.join
     end
     
     def first uri, context, *args
@@ -11,29 +11,57 @@ module Ldpath
     def last uri, context, *args
       args.flatten.compact.last
     end
+
+    def count uri, context, *args
+      args.flatten.compact.length
+    end
     
     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
-      
+      a, b, *rem = args.flatten
+      unless rem.empty?
+        raise "Too many arguments to fn:ne"
+      end
+      a != b
     end
     
     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
-      
+      a, b, *rem = args.flatten
+      unless rem.empty?
+        raise "Too many arguments to fn:le"
+      end
+      a <= b
     end
     
     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
-      
+      a, b, *rem = args.flatten
+      unless rem.empty?
+        raise "Too many arguments to fn:ge"
+      end
+      a >= b
     end
     
     # collections
@@ -130,7 +158,6 @@ module Ldpath
     end
     
     def endsWith uri, context, str, suffix
-      
       Array(str).map { |x| x.end_with? suffix }
     end
     
@@ -141,6 +168,13 @@ module Ldpath
     def predicates uri, context, *args
       context.query([uri, nil, nil]).map(&:predicate).uniq
     end
+
+    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)
+      end
+    end
   
   end
 end

data/lib/ldpath/parser.rb

@@ -4,15 +4,21 @@ module Ldpath
   class Parser < Parslet::Parser
     root :lines
     rule(:lines) { line.repeat }
-    rule(:line) { expression >> wsp? >> (newline | eof) }
+    rule(:line) { ((wsp >> expression) | expression) >> space_not_newline? >> (newline | eof) }
 
     rule(:newline) {  (str("\n") >> str("\r").maybe).repeat(1) }
     rule(:eof) { any.absent? }
-    rule(:wsp) { (match["\\t "] | multiline_comment).repeat(1) }
+
+    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(:wsp) { (space | multiline_comment).repeat(1) }
     rule(:wsp?) { wsp.maybe }
     rule(:multiline_comment) { (str('/*') >> (str('*/').absent? >> any).repeat >> str('*/') ) }
 
-    rule(:expression) { wsp | namespace | mapping | graph }
+    rule(:expression) { wsp | namespace | mapping | graph | filter | boost }
     
     rule(:int) { match("\\d+") }
     
@@ -23,6 +29,8 @@ module Ldpath
     rule(:assign) { str("=") }
     rule(:k_prefix) { str("@prefix")}
     rule(:k_graph) { str("@graph")}
+    rule(:k_filter) { str("@filter")}
+    rule(:k_boost) { str("@boost")}
     
     rule(:self_op) { str(".") }
     rule(:and_op) { str("&") }
@@ -57,9 +65,7 @@ module Ldpath
     rule(:identifier) { match["a-zA-Z0-9_"] >> (match["a-zA-Z0-9_'\\.-"]).repeat }
 
     rule(:strlit) {
-      wsp? >> 
-      str('"') >> (str("\\") >> str("\"") | (str('"').absent? >> any)).repeat.as(:literal) >> str('"') >> 
-      wsp?
+      str('"') >> (str("\\") >> str("\"") | (str('"').absent? >> any)).repeat.as(:literal) >> str('"')
     }
 
     rule(:node) {
@@ -69,24 +75,20 @@ module Ldpath
     # @prefix id = uri ;
     rule(:namespace) { 
       (
-      wsp? >>
       k_prefix >> wsp? >>
       identifier.as(:id) >> wsp? >>
       colon >> wsp? >>
-      uri.as(:uri) >> wsp? >>
-      scolon.maybe >> 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
+      uri_list.as(:graphs) >> wsp? >> scolon
     }
     
     rule(:uri_list) {
-      wsp? >> 
       uri.as(:uri) >>
       (
         wsp? >> 
@@ -94,22 +96,41 @@ module Ldpath
         uri_list.as(:rest)
       ).repeat
     }
+
+    # @filter test ;
+    rule(:filter) {
+      (k_filter >> wsp? >> node_test.as(:test) >> wsp? >> scolon).as(:filter)
+    }
+
+    # @boost selector ;
+    rule(:boost) {
+      (k_boost >> wsp? >> selector.as(:selector) >> wsp? >> scolon).as(:boost)
+    }
     
     # id = . ;
     rule(:mapping) {
       (
-        identifier.as(:name) >> wsp? >>
+        (uri_in_brackets | prefix_and_localname | identifier).as(:name) >> wsp? >>
         assign >> wsp? >>
-        selector.as(:selector) >> wsp? >>
-        (
-          dcolon >> wsp? >>
-          uri.as(:field_type)
-        ).maybe >> wsp? >>
-        scolon
+        selector.as(:selector) >>
+        ( wsp? >> 
+          dcolon >> wsp? >> field_type
+        ).maybe >> wsp? >> scolon
       ).as(:mapping)
     }
 
+    rule(:field_type) {
+      uri.as(:field_type) >> field_type_options.maybe
+    }
+
+    rule(:field_type_options) {
+      str("(") >> wsp? >> (field_type_option >> (wsp? >> comma >> wsp? >> field_type_option).repeat).as(:options) >> wsp? >> str(")")
+    }
 
+    rule(:field_type_option) {
+      identifier.as(:key) >> wsp? >> assign >> wsp? >> strlit.as(:value)
+    }
+    
     # selector groups
     rule(:selector) {
       (
@@ -128,11 +149,10 @@ module Ldpath
     }
     
     rule(:testing_selector) {
-      wsp? >>
       atomic_selector.as(:delegate) >>
       str("[") >> wsp? >>
       node_test.as(:test) >> wsp? >>
-      str("]") >> wsp?
+      str("]")
     }
 
     rule(:atomic_selector) {
@@ -163,80 +183,70 @@ module Ldpath
     ## x / y
     rule(:path_selector) {
       (
-        wsp? >>
         atomic_or_testing_selector.as(:left) >> wsp? >>
         p_sep >> wsp? >>
-        atomic_or_testing_or_path_selector.as(:right) >> wsp?
+        atomic_or_testing_or_path_selector.as(:right)
       ).as(:path)
     }
     
     ## x & y
     rule(:intersection_selector) {
       (
-        wsp? >>
         atomic_or_testing_or_path_selector.as(:left) >> wsp? >>
         and_op >> wsp? >>
-        selector.as(:right) >> wsp?
+        selector.as(:right)
       ).as(:intersection)
     }
     
     ## x | y
     rule(:union_selector) {
       (
-        wsp? >>
         atomic_or_testing_or_path_selector.as(:left) >> wsp? >>
         or_op >> wsp? >>
-        selector.as(:right) >> wsp?
+        selector.as(:right)
       ).as(:union)
     }
 
     # Atomic Selectors
     rule(:self_selector) {
-      wsp? >> 
-      self_op.as(:self) >> wsp?
+      self_op.as(:self)
     }
     
     # fn:x() or fn:x(1,2,3)
     rule(:function_selector) {
       func >> identifier.as(:fname) >> str("()") |
-      func >> identifier.as(:fname) >> str("(") >> arglist.as(:arglist) >> str(")")
+      func >> identifier.as(:fname) >> str("(") >> wsp? >> arglist.as(:arglist) >> wsp? >> str(")")
     }
     
     rule(:arglist) {
-      wsp? >>
       selector >> 
       (
         wsp? >> 
         comma >> wsp? >> 
         selector
-      ).repeat >>
-      wsp?
+      ).repeat
     }
     
     # xyz
     rule(:loose_property_selector) {
-      wsp? >> 
       loose >> 
       wsp? >> 
-      uri.as(:loose_property) >> wsp?
+      uri.as(:loose_property)
     }
 
     # xyz
     rule(:property_selector) {
-      wsp? >> 
-      uri.as(:property) >> wsp?
+      uri.as(:property)
     }
 
     # *
     rule(:wildcard_selector) {
-      wsp? >> 
-      star.as(:wildcard) >> wsp?
+      star.as(:wildcard)
     }
 
     # ^xyz
     rule(:reverse_property_selector) {
-      wsp? >> 
-      inverse >> uri.as(:reverse_property) >> wsp?
+      inverse >> uri.as(:reverse_property)
     }
     
     rule(:string_constant_selector) {
@@ -246,7 +256,6 @@ module Ldpath
     # (x)*
     rule(:recursive_path_selector) {
       (
-        wsp? >> 
         str("(") >> wsp? >>
         selector.as(:delegate) >> wsp? >> 
         str(")") >>
@@ -254,23 +263,21 @@ module Ldpath
           star |
           plus |
           (str("{") >> wsp? >> int.as(:min).maybe >> wsp? >>str(",") >> wsp? >> int.as(:max).maybe >> wsp? >>str("}") ).as(:range)
-        ).as(:repeat) >> wsp?
+        ).as(:repeat)
       ).as(:recursive)
     }
     
     rule(:grouped_selector) {
-      wsp? >>
       str("(") >> wsp? >> 
       selector >> wsp? >> 
-      str(")") >> wsp?
+      str(")")
     }
 
     rule(:tap_selector) {
-      wsp? >>
       tap >>
-      str("<") >>
-      identifier.as(:identifier) >>
-      str(">") >>
+      str("<") >> wsp? >>
+      identifier.as(:identifier) >> wsp? >>
+      str(">") >> wsp? >>
       (atomic_selector).as(:tap)
     }
     
@@ -294,78 +301,67 @@ module Ldpath
     }
 
     rule(:grouped_test) {
-      wsp? >> 
       str("(")  >> wsp? >> 
       node_test >> wsp? >> 
-      str(")")  >> wsp?
+      str(")") 
     }
     
     rule(:not_test) {
       (
-        wsp? >> 
-        not_op >> node_test.as(:delegate) >> 
-        wsp?
+        not_op >> node_test.as(:delegate)
       ).as(:not)
     }
     
     rule(:and_test) {
       (
-        wsp? >> 
         atomic_node_test.as(:left) >> wsp? >> 
         and_op >> wsp? >> 
-        node_test.as(:right) >> wsp?
+        node_test.as(:right)
       ).as(:and)
     }
     
     rule(:or_test) {
       (
-        wsp? >> 
         atomic_node_test.as(:left) >> wsp? >> 
         or_op >> wsp? >> 
-        node_test.as(:right) >> wsp?
+        node_test.as(:right)
       ).as(:or)
     }
 
     # @en
     rule(:literal_language_test) {
-      wsp? >> 
-      lang >> identifier.as(:lang) >> 
-      wsp?
+      lang >> identifier.as(:lang)
     }
     
     # ^^xyz
     rule(:literal_type_test) {
-      wsp? >> 
-      type >> uri.as(:type) >> 
-      wsp?
+      type >> uri.as(:type)
     }
     
     rule(:is_a_test) {
       (
-        wsp? >> 
         is_a >> wsp? >> 
-        node.as(:right) >> 
-        wsp?
+        node.as(:right)
       ).as(:is_a)
     }
     
     rule(:path_equality_test) {
       (
-        wsp? >>
         selector >> wsp? >>
         is >> wsp? >>
-        node.as(:right) >> wsp?
+        node.as(:right)
       ).as(:is)
     }
     
     rule(:function_test) {
-      wsp? >>
       (
       func >> identifier.as(:fname) >> str("()") |
       func >> identifier.as(:fname) >> str("(") >>
+        wsp? >> 
           arglist.as(:arglist) >>
+        wsp? >> 
       str(")")
-      ) >> wsp?
+      )
     }
 
     rule(:path_test) {

data/lib/ldpath/program.rb

@@ -8,7 +8,7 @@ module Ldpath
         parsed = parser.parse(program)
         ast = transform.apply parsed, transform_context
 
-        Ldpath::Program.new ast.compact
+        Ldpath::Program.new ast.compact, transform_context
       end
 
       private
@@ -21,16 +21,19 @@ module Ldpath
       end
     end
     
-    attr_reader :mappings, :cache, :loaded
-    def initialize mappings, cache = RDF::Util::Cache.new
+    attr_reader :mappings, :cache, :loaded, :prefixes, :filters
+    def initialize mappings, options = {}
+
       @mappings ||= mappings
-      @cache = cache
+      @cache = options[:cache] || RDF::Util::Cache.new
+      @prefixes = options[:prefixes] || {}
+      @filters = options[:filters] || []
       @loaded = {}
     end
     
     def loading uri, context
-      if uri.to_s =~ /^http/ and !loaded[uri]
-        context << load_graph(uri)
+      if uri.to_s =~ /^http/ and !loaded[uri.to_s]
+        context << load_graph(uri.to_s)
       end
     end
 
@@ -50,6 +53,10 @@ module Ldpath
       h = {}
       context ||= load_graph(uri.to_s)
 
+      unless filters.empty?
+        return h unless filters.all? { |f| f.evaluate(self, uri, context) }
+      end
+
       mappings.each do |m|
         h[m.name] ||= []
         h[m.name] += case m.selector

data/lib/ldpath/selectors.rb

@@ -37,7 +37,7 @@ module Ldpath
             i
           end
         end
-        program.func_call fname, uri, context, args
+        program.func_call fname, uri, context, *args
       end.flatten.compact
     end
   end

data/lib/ldpath/transform.rb

@@ -21,6 +21,7 @@ module Ldpath
 
     def apply obj, context = nil
       context ||= { }
+      context[:filters] ||= []
       context[:prefixes] ||= {}.merge(self.class.default_prefixes)
       super obj, context
     end
@@ -38,6 +39,17 @@ module Ldpath
     rule(prefix: simple(:prefix), localName: simple(:localName)) do
       (prefixes[prefix.to_s] || RDF::Vocabulary.new(prefix.to_s))[localName]
     end
+    
+    rule(filter: subtree(:filter)) do
+      filters << filter[:test]
+      nil
+    end
+
+    rule(boost: subtree(:boost)) do
+      # no-op
+      nil
+    end
+
 
     # Mappings
     

data/lib/ldpath/version.rb

@@ -1,3 +1,3 @@
 module Ldpath
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/spec/fixtures/program.ldpath

@@ -19,11 +19,9 @@
 
 @graph test:context, foo:ctx, test:bar ;
 
-/*
 @filter test:type is foo:bar | test:p1 & is-a test:Case ;
 
 @boost foo:boost / ^test:boost ;
-*/
 
 path = test:p1 / test:p2 :: test:type ;
 lang_test = test:p1[@en] :: test:type ;
@@ -34,8 +32,7 @@ group = (test:p1 / test:p2) :: test:type ;
 
 inverse = ^test:incoming :: test:type ;
 
-config = test:foo :: test:type ;
-/*
+config = test:foo :: test:type(c1="true", c2="false", c3="1.234") ;
+
 foo:bar = test:foo :: test:type ;
-<http://test/> = test:test :: test:type ;
-*/
+<http://test/> = test:test :: test:type ;

data/spec/ldpath_parser_spec.rb

@@ -64,6 +64,11 @@ describe Ldpath::Parser do
         subject.expression.parse "@graph test:context, foo:ctx, test:bar ;"
       end
       
+
+      it "may be a filter" do
+        subject.expression.parse "@filter is-a test:Context ;"
+      end
+      
       it "may be a mapping" do
         subject.expression.parse "id = . ;"
       end
@@ -133,7 +138,7 @@ describe Ldpath::Parser do
       end
       
       it "should parse path mappings" do
-        subject.parse("xyz = info:a / info:b :: a:b;\n")
+        subject.mapping.parse("xyz = info:a / info:b :: a:b;")
       end
       
       it "recursive_path_selector" do
@@ -163,7 +168,7 @@ describe Ldpath::Parser do
       end
       
       it "should parse the namespaces.ldpath" do
-        subject.parse File.read(File.expand_path(File.join(__FILE__, "..", "fixtures", "namespaces.ldpath")))
+        subject.parse_with_debug File.read(File.expand_path(File.join(__FILE__, "..", "fixtures", "namespaces.ldpath")))
       end
     end  
   end

data/spec/ldpath_program_spec.rb

@@ -72,33 +72,114 @@ EOF
   end
   
   describe "functions" do
-    
-      subject do
-        Ldpath::Program.parse <<-EOF
+    let(:program) do
+      Ldpath::Program.parse <<-EOF
 @prefix dcterms : <http://purl.org/dc/terms/> ;
 ab = fn:concat("a", "b") ;
 title = fn:concat(dcterms:title, dcterms:description) ;
+title_mix = fn:concat("!", dcterms:title) ;
+title_missing = fn:concat("z", dcterms:genre) ;
 first_a = fn:first("a", "b") ;
+first_b = fn:first(dcterms:genre, "b") ;
+last_a = fn:last("a", dcterms:genre) ;
 last_b = fn:last("a", "b") ;
+count_5 = fn:count("a", "b", "c", "d", "e");
+count_3 = fn:count(dcterms:hasPart);
+count_still_3 = fn:count(dcterms:hasPart, dcterms:genre);
+eq_true = fn:eq("a", "a");
+eq_false = fn:eq("a", "b");
+eq_node_true = fn:eq(dcterms:description, "Description");
+xpath_test = fn:xpath("//title", "<root><title>xyz</title></root>");
 EOF
+    end
+
+    let(:object) { RDF::URI.new("info:a") }
+    
+    let(:graph) do
+      graph = RDF::Graph.new
+      graph << [object, RDF::DC.title, "Hello, world!"]
+      graph << [object, RDF::DC.description, "Description"]
+      graph << [object, RDF::DC.hasPart, "a"]
+      graph << [object, RDF::DC.hasPart, "b"]
+      graph << [object, RDF::DC.hasPart, "c"]
+
+      graph
+    end
+
+    subject do
+      program.evaluate object, graph
+    end
+
+    describe "concat" do
+      it "should concatenate simple string arguments" do
+        expect(subject).to include "ab" => ["ab"]
       end
 
-      let(:object) { RDF::URI.new("info:a") }
-      
-      let(:graph) do
-        graph = RDF::Graph.new
-        graph << [object, RDF::DC.title, "Hello, world!"]
-        graph << [object, RDF::DC.description, "Description"]
+      it "should concatenate node values" do
+        expect(subject).to include "title" => ["Hello, world!Description"]
+      end
 
-        graph
+      it "should allow a mixture of string and node values" do
+        expect(subject).to include "title_mix" => ["!Hello, world!"]
+      end
+
+      it "should ignore missing node values" do
+        expect(subject).to include "title_missing" => ["z"]
+      end
+    end
+
+    describe "first" do
+      it "should take the first value" do
+        expect(subject).to include "first_a" => ["a"]
+      end
+
+      it "should skip missing values" do
+        expect(subject).to include "first_b" => ["b"]
+      end
+    end
+    
+    describe "last" do
+      it "should take the last value" do
+        expect(subject).to include "last_b" => ["b"]
+      end
+
+      it "should skip missing values" do
+        expect(subject).to include "last_a" => ["a"]
+      end
+    end
+
+    describe "count" do
+      it "should return the number of arguments" do
+        expect(subject).to include "count_5" => [5]
+      end
+
+      it "should count the number of values for nodes" do
+        expect(subject).to include "count_3" => [3]
+      end
+
+      it "should skip missing nodes" do
+        expect(subject).to include "count_still_3" => [3]
+      end
+    end
+
+    describe "eq" do
+      it "checks if the arguments match" do
+        expect(subject).to include "eq_true" => [true]
+      end
+
+      it "checks if the arguments fail to match" do
+        expect(subject).to include "eq_false" => [false]
+      end
+
+      it "checks node values" do
+        expect(subject).to include "eq_node_true" => [true]
+      end
+    end
+
+    describe "xpath" do
+      it "evaluates xpath queries against the string contents" do
+        expect(subject).to include "xpath_test" => ["xyz"]
       end
-      
-    it "should work" do
-      result = subject.evaluate object, graph
-      expect(result["ab"]).to match_array "ab"
-      expect(result["title"]).to match_array "Hello, world!Description"
-      expect(result["first_a"]).to match_array "a"
-      expect(result["last_b"]).to match_array "b"
     end
   end
   
@@ -192,4 +273,42 @@ title_with_loose =  ~dc:title :: xsd:string ;
       expect(result["title_with_loose"]).to eq result["title"]
     end
   end
+
+  describe "filter" do
+    
+    subject do
+      Ldpath::Program.parse <<-EOF
+    @prefix dcterms : <http://purl.org/dc/terms/> ;
+    @prefix dc: <http://purl.org/dc/elements/1.1/> ;
+    @filter is-a dcterms:Agent ;
+    title = dcterms:title :: xsd:string ;
+      EOF
+    end
+
+    let(:object) { RDF::URI.new("info:a") }
+    let(:other_object) { RDF::URI.new("info:b") }
+    
+    
+    let(:graph) do
+      graph = RDF::Graph.new
+      
+      graph << [object, RDF.type, RDF::DC.Agent]
+      graph << [object, RDF::DC.title, "Title"]
+      graph << [other_object, RDF::DC.title, "Other Title"]
+
+      graph
+    end
+    
+    it "should work" do
+      result = subject.evaluate object, graph
+      expect(result["title"]).to eq ["Title"]
+    end
+    
+    it "filters objects that don't match" do
+      result = subject.evaluate other_object, graph
+      expect(result).to be_empty
+    end
+
+
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ldpath
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Chris Beer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-02 00:00:00.000000000 Z
+date: 2015-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -97,7 +97,8 @@ dependencies:
 description: 
 email:
 - cabeer@stanford.edu
-executables: []
+executables:
+- ldpath
 extensions: []
 extra_rdoc_files: []
 files:
@@ -108,6 +109,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/ldpath
 - ldpath.gemspec
 - lib/ldpath.rb
 - lib/ldpath/field_mapping.rb
@@ -126,7 +128,7 @@ files:
 - spec/ldpath_spec.rb
 - spec/ldpath_transform_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/cbeer
+homepage: https://github.com/cbeer/ldpath.rb
 licenses:
 - Apache 2
 metadata: {}
@@ -146,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of LDPath