pho 0.4.1 → 0.5

data/lib/pho/store.rb

@@ -170,6 +170,23 @@ module Pho
     # SERVICES
     #############
     
+    #Retrieve a SparqlClient object for interacting with the endpoint for this store
+    #
+    # multisparql:: optional, set to true to retrieve client for multisparql endpoint
+    def sparql_client(multisparql=false)
+      if multisparql
+        u = self.build_uri("/services/multisparql")
+      else
+        u = self.build_uri("/services/sparql")    
+      end
+      
+      sparql_client = Pho::Sparql::SparqlClient.new(u, @client)
+      sparql_client.supports_rdf_json = true
+      sparql_client.supports_sparql_json = true
+      
+      return sparql_client      
+    end
+    
     #Perform a SPARQL DESCRIBE query.
     #
     # query:: the SPARQL query
@@ -208,19 +225,7 @@ module Pho
     # format:: the preferred response format
     # multisparql:: use default sparql service or multisparql service
     def sparql(query, format=nil, multisparql=false)
-      if multisparql
-        u = self.build_uri("/services/multisparql")
-      else
-        u = self.build_uri("/services/sparql")    
-      end
-      
-      params = {}
-      params["query"] = query
-      headers = {}
-      if format != nil
-        headers["Accept"] = format  
-      end      
-      response = @client.get(u, params, headers)        
+      return sparql_client(multisparql).query(query, format)              
     end    
     
     # Search the Metabox indexes.
@@ -291,7 +296,7 @@ module Pho
     # data:: a String containing the RSS feed
     def augment(data)
       u = self.build_uri("/services/augment")
-      response = @client.post(u, data, nil)
+      response = @client.post(u, data, {"Content-Type" => "application/rss+xml"})
       return response
     end
         
@@ -330,6 +335,7 @@ module Pho
       data = f.read()
       f.close()
       headers = {"Content-Type" => mimetype}
+      
       if uri == nil
         u = self.build_uri("/items")        
         response = @client.post(u, data, headers)

data/tests/tc_changeset.rb

@@ -167,6 +167,52 @@ class ChangesetTest < Test::Unit::TestCase
             
   end
 
+  def test_to_rdf_with_typed_literal
+    cs = Pho::Update::Changeset.new("http://www.example.org/my-resource") do |c|
+      c.add_addition( Pho::Update::Statement.create_literal("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "literal", 
+        nil, "http://www.example.org/type") )
+    end    
+    assert_equal(1, cs.additions.length)
+    
+    cs_el = get_changeset(cs.to_rdf)
+    
+    addition = REXML::XPath.first(cs_el, "cs:addition", Pho::Namespaces::MAPPING)
+    assert_not_nil(addition)
+    statement = REXML::XPath.first(addition, "rdf:Statement", Pho::Namespaces::MAPPING)
+    assert_not_nil(statement)
+    el = REXML::XPath.first(statement, "rdf:subject", Pho::Namespaces::MAPPING)
+    assert_equal("http://www.example.org/my-resource", el.attributes["rdf:resource"])
+    el = REXML::XPath.first(statement, "rdf:predicate", Pho::Namespaces::MAPPING)
+    assert_equal("http://xmlns.com/foaf/0.1/homePage", el.attributes["rdf:resource"])
+    el = REXML::XPath.first(statement, "rdf:object", Pho::Namespaces::MAPPING)
+    assert_equal(nil, el.attributes["rdf:resource"])
+    assert_equal("literal", el.text)
+    assert_equal( "http://www.example.org/type", el.attributes["rdf:datatype"] )
+    assert_equal(nil, el.attributes["xml:lang"])        
+  end  
+
+  def test_to_rdf_with_language_literal
+    cs = Pho::Update::Changeset.new("http://www.example.org/my-resource") do |c|
+      c.add_addition( Pho::Update::Statement.create_literal("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "literal", "fr") )
+    end    
+    assert_equal(1, cs.additions.length)
+    
+    cs_el = get_changeset(cs.to_rdf)
+    
+    addition = REXML::XPath.first(cs_el, "cs:addition", Pho::Namespaces::MAPPING)
+    assert_not_nil(addition)
+    statement = REXML::XPath.first(addition, "rdf:Statement", Pho::Namespaces::MAPPING)
+    assert_not_nil(statement)
+    el = REXML::XPath.first(statement, "rdf:subject", Pho::Namespaces::MAPPING)
+    assert_equal("http://www.example.org/my-resource", el.attributes["rdf:resource"])
+    el = REXML::XPath.first(statement, "rdf:predicate", Pho::Namespaces::MAPPING)
+    assert_equal("http://xmlns.com/foaf/0.1/homePage", el.attributes["rdf:resource"])
+    el = REXML::XPath.first(statement, "rdf:object", Pho::Namespaces::MAPPING)
+    assert_equal(nil, el.attributes["rdf:resource"])
+    assert_equal("literal", el.text)
+    assert_equal( nil, el.attributes["rdf:datatype"] )
+    assert_equal("fr", el.attributes["xml:lang"])        
+  end      
   def test_to_rdf_with_resource_removal
     cs = Pho::Update::Changeset.new("http://www.example.org/my-resource") do |c|
       c.add_removal( Pho::Update::Statement.create_resource("http://www.example.org/my-resource", "http://xmlns.com/foaf/0.1/homePage", "http://www.example.org/page") )

data/tests/tc_changeset_builder.rb

@@ -44,7 +44,109 @@ class ChangesetBuilderTest < Test::Unit::TestCase
   }
   EOL
 
+#  COLLECTION = <<-EOL
+#  <rdf:RDF xmlns:rdf      = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+#           xmlns:ex       = "http://www.example.org/ns/">
+#  
+#    <rdf:Description rdf:about="http://www.example.org">
+#      <ex:list rdf:parseType="Collection">
+#         <rdf:Description rdf:about="http://www.example.org/first"/>
+#         <rdf:Description rdf:about="http://www.example.org/second"/>
+#         <rdf:Description rdf:about="http://www.example.org/third"/>         
+#      </ex:list>
+#    </rdf:Description>
+#    
+#  </rdf:RDF>  
+#  EOL
+#
+#  SHORT_COLLECTION = <<-EOL
+#  <rdf:RDF xmlns:rdf      = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+#           xmlns:ex       = "http://www.example.org/ns/">
+#  
+#    <rdf:Description rdf:about="http://www.example.org">
+#      <ex:list rdf:parseType="List">
+#         <rdf:Description rdf:about="http://www.example.org/first"/>
+#         <rdf:Description rdf:about="http://www.example.org/second"/>         
+#      </ex:list>
+#    </rdf:Description>
+#    
+#  </rdf:RDF>  
+#  EOL
+
+  COLLECTION = <<-EOL
+  <rdf:RDF xmlns:rdf      = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+           xmlns:ex       = "http://www.example.org/ns/">
+  
+    <rdf:Description rdf:about="http://www.example.org">
+      <ex:list rdf:resource="http://www.example.org/list#first"/>
+    </rdf:Description>
+  <rdf:Description rdf:about="http://www.example.org/list#first">
+     <rdf:first rdf:resource="http://www.example.org/first"/>
+     <rdf:rest rdf:resource="http://www.example.org/list#second"/>
+  </rdf:Description>
+  <rdf:Description rdf:about="http://www.example.org/list#second">
+    <rdf:first rdf:resource="http://www.example.org/second"/>
+    <rdf:rest rdf:resource="http://www.example.org/second"/>
+  </rdf:Description>
+  <rdf:Description rdf:about="http://www.example.org/list#third">
+   <rdf:first rdf:resource="http://www.example.org/third"/>
+   <rdf:rest rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"/>
+  </rdf:Description>                  
+    
+  </rdf:RDF>  
+  EOL
+
+  SHORT_COLLECTION = <<-EOL
+  <rdf:RDF xmlns:rdf      = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+           xmlns:ex       = "http://www.example.org/ns/">
+  
+    <rdf:Description rdf:about="http://www.example.org">
+      <ex:list rdf:resource="http://www.example.org/list#first"/>
+    </rdf:Description>
+  <rdf:Description rdf:about="http://www.example.org/list#first">
+     <rdf:first rdf:resource="http://www.example.org/first"/>
+     <rdf:rest rdf:resource="http://www.example.org/list#second"/>
+  </rdf:Description>
+  <rdf:Description rdf:about="http://www.example.org/list#second">
+    <rdf:first rdf:resource="http://www.example.org/second"/>
+  <rdf:rest rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"/>
+  </rdf:Description>
     
+  </rdf:RDF>    
+  EOL
+  
+  SEQUENCE = <<-EOL
+  <rdf:RDF xmlns:rdf      = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+           xmlns:ex       = "http://www.example.org/ns/">
+  
+    <rdf:Description rdf:about="http://www.example.org">
+      <ex:list>
+         <rdf:Seq>
+         <rdf:li><rdf:Description rdf:about="http://www.example.org/first"/></rdf:li>
+         <rdf:li><rdf:Description rdf:about="http://www.example.org/second"/></rdf:li>
+         <rdf:li><rdf:Description rdf:about="http://www.example.org/third"/></rdf:li>
+         </rdf:Seq>         
+      </ex:list>
+    </rdf:Description>
+    
+  </rdf:RDF>  
+  EOL
+
+  SHORT_SEQUENCE = <<-EOL
+  <rdf:RDF xmlns:rdf      = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+           xmlns:ex       = "http://www.example.org/ns/">
+  
+  <rdf:Description rdf:about="http://www.example.org">
+    <ex:list>
+       <rdf:Seq>
+       <rdf:li><rdf:Description rdf:about="http://www.example.org/first"/></rdf:li>
+       <rdf:li><rdf:Description rdf:about="http://www.example.org/second"/></rdf:li>
+       </rdf:Seq>         
+    </ex:list>
+  </rdf:Description>    
+  </rdf:RDF>  
+  EOL
+          
     def test_build_with_single_triple1
         
       cs = Pho::Update::ChangesetBuilder.build("http://www.example.org", JSON.parse("{}"), JSON.parse( SINGLE_TRIPLE_RESOURCE ) )
@@ -147,5 +249,24 @@ class ChangesetBuilderTest < Test::Unit::TestCase
     assert_equal("Bob Bobson", first_uri_changes.creator_name)  
     assert_equal("Because I can", first_uri_changes.change_reason)
     
-  end              
+  end
+  
+  def test_batch_changeset_with_list
+    coll_hash = Pho::ResourceHash::Converter.parse_rdfxml(COLLECTION, "http://www.example.com")
+    short_coll_hash = Pho::ResourceHash::Converter.parse_rdfxml(SHORT_COLLECTION, "http://www.example.com")
+    changesets = Pho::Update::ChangesetBuilder.build_batch(coll_hash, short_coll_hash, "Bob Bobson", "Because I can" )
+    #2 because we've updated the head and tail of the list
+    assert_equal(2, changesets.length)
+    
+    changesets = Pho::Update::ChangesetBuilder.build_batch(short_coll_hash, coll_hash, "Bob Bobson", "Because I can" )
+    #2 because we've updated the head and tail of the list
+    assert_equal(2, changesets.length)    
+  end
+
+#  def test_batch_changeset_with_sequence
+#    hash = Pho::ResourceHash::Converter.parse_rdfxml(SEQUENCE, "http://www.example.com")
+#    puts hash.inspect()
+#  end
+    
+                
 end

data/tests/tc_converter.rb

@@ -0,0 +1,95 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'pho'
+require 'test/unit'
+require 'rexml/document'
+
+class ConverterTest < Test::Unit::TestCase
+  
+  SINGLE_RESOURCE_JSON = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/resource" : [ { "value" : "http://www.example.org/page", "type" : "uri" } ]
+    }
+  }
+  EOL
+
+  SINGLE_RESOURCE_RDFXML = <<-EOL
+  <rdf:RDF xmlns:rdf      = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+           xmlns:ex       = "http://www.example.org/ns/">
+  
+    <rdf:Description rdf:about="http://www.example.org">
+      <ex:resource rdf:resource="http://www.example.org/page"/>
+    </rdf:Description>
+    
+  </rdf:RDF>
+  
+  EOL
+  
+  SINGLE_RESOURCE_NTRIPLES = <<-EOL
+  <http://www.example.org> <http://www.example.org/ns/resource> <http://www.example.org/page>.
+  EOL
+
+  SINGLE_RESOURCE_TURTLE = <<-EOL
+  <http://www.example.org> <http://www.example.org/ns/resource> <http://www.example.org/page>.
+  EOL
+      
+  def test_parse_json
+    
+    hash = Pho::ResourceHash::Converter.parse_json(SINGLE_RESOURCE_JSON)
+    assert_not_nil(hash)
+    assert_not_nil(hash["http://www.example.org"])
+    
+  end
+  
+  def test_parse_rdfxml
+
+    hash = Pho::ResourceHash::Converter.parse_rdfxml(SINGLE_RESOURCE_RDFXML, "http://www.example.org")
+    assert_not_nil(hash)
+    assert_not_nil(hash["http://www.example.org"])
+    
+    predicates = hash["http://www.example.org"]
+    assert_equal(1, predicates.size() )
+    assert_equal(1, predicates["http://www.example.org/ns/resource"].length)
+    assert_equal("http://www.example.org/page", predicates["http://www.example.org/ns/resource"][0]["value"])
+    assert_equal("uri", predicates["http://www.example.org/ns/resource"][0]["type"])
+  end
+  
+  def test_parse_ntriples
+    
+    hash = Pho::ResourceHash::Converter.parse_ntriples(SINGLE_RESOURCE_NTRIPLES, "http://www.example.org")
+    assert_not_nil(hash)
+    assert_not_nil(hash["http://www.example.org"])
+    
+    predicates = hash["http://www.example.org"]
+    assert_equal(1, predicates.size() )
+    assert_equal(1, predicates["http://www.example.org/ns/resource"].length)
+    assert_equal("http://www.example.org/page", predicates["http://www.example.org/ns/resource"][0]["value"])
+    assert_equal("uri", predicates["http://www.example.org/ns/resource"][0]["type"])
+    
+  end
+
+  def test_parse_turtle
+    
+    hash = Pho::ResourceHash::Converter.parse_ntriples(SINGLE_RESOURCE_TURTLE, "http://www.example.org")
+    assert_not_nil(hash)
+    assert_not_nil(hash["http://www.example.org"])
+    
+    predicates = hash["http://www.example.org"]
+    assert_equal(1, predicates.size() )
+    assert_equal(1, predicates["http://www.example.org/ns/resource"].length)
+    assert_equal("http://www.example.org/page", predicates["http://www.example.org/ns/resource"][0]["value"])
+    assert_equal("uri", predicates["http://www.example.org/ns/resource"][0]["type"])
+    
+  end
+  
+  def test_serialize_json
+    parsed = Pho::ResourceHash::Converter.parse_json(SINGLE_RESOURCE_JSON)
+    
+    serialized = Pho::ResourceHash::Converter.serialize_json(parsed)    
+    reparsed = Pho::ResourceHash::Converter.parse_json(serialized)
+    
+    assert_equal(parsed, reparsed)
+     
+  end  
+    
+end

data/tests/tc_enrichment.rb

@@ -0,0 +1,83 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'pho'
+require 'test/unit'
+require 'mocha'
+
+class EnrichmentTest < Test::Unit::TestCase
+  
+  RDFXML = <<-EOL 
+  <rdf:RDF xmlns:rdf      = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+           xmlns:ex       = "http://www.example.org/ns/">
+  
+    <rdf:Description rdf:about="http://www.example.org">
+      <ex:resource rdf:resource="http://www.example.org/page"/>
+    </rdf:Description>
+    
+  </rdf:RDF>    
+  EOL
+
+  def test_merge()
+    
+    query = "DESCRIBE <http://www.example.org>"
+    mock_store = mock()
+    mock_store.expects(:store_data).with(RDFXML).returns( HTTP::Message.new_response("OK") )
+    
+    mc = mock()
+    mc.expects(:query).with( query, "application/rdf+xml" ).returns( HTTP::Message.new_response(RDFXML) )
+    
+    enricher = Pho::Enrichment::ResourceEnricher.new(mock_store, mc)
+    resp = enricher.merge(query) 
+    assert_not_nil(resp)
+
+  end
+
+  def test_merge_with_failed_query()
+    
+    query = "DESCRIBE <http://www.example.org>"
+    mock_store = mock()
+    
+    mc = mock()
+    msg = HTTP::Message.new_response("Error")
+    msg.status = 500
+    mc.expects(:query).with( query, "application/rdf+xml" ).returns( msg )
+    
+    enricher = Pho::Enrichment::ResourceEnricher.new(mock_store, mc)
+    assert_raises RuntimeError do        
+        results = enricher.merge(query)
+    end
+
+  end
+  
+  def test_merge_with_failed_store()
+    
+    query = "DESCRIBE <http://www.example.org>"
+    mock_store = mock()
+    msg = HTTP::Message.new_response("Error")
+    msg.status = 500    
+    mock_store.expects(:store_data).with(RDFXML).returns( msg )
+    
+    mc = mock()
+    mc.expects(:query).with( query, "application/rdf+xml" ).returns( HTTP::Message.new_response(RDFXML) )
+    
+    enricher = Pho::Enrichment::ResourceEnricher.new(mock_store, mc)
+    resp = enricher.merge(query) 
+    assert_equal(500, resp.status)
+    
+  end
+  
+  def test_infer()
+    query = "CONSTRUCT { ?s ex:foo ?o } WHERE { ?s ex:bar ?o }"
+        
+    mc = mock()
+    mc.expects(:query).with( query, "application/rdf+xml" ).returns( HTTP::Message.new_response(RDFXML) )
+
+    mock_store = mock()
+    mock_store.expects(:sparql_client).returns(mc)
+    mock_store.expects(:store_data).with(RDFXML).returns( HTTP::Message.new_response("OK") )
+       
+    resp = Pho::Enrichment::ResourceEnricher.infer(mock_store, query) 
+    assert_not_nil(resp)
+
+  end  
+    
+end

data/tests/tc_file_manager.rb

@@ -0,0 +1,88 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'pho'
+require 'test/unit'
+require 'mocha'
+
+class FileManagerTest < Test::Unit::TestCase
+
+  def setup()
+    Dir.mkdir("/tmp/pho") unless File.exists?("/tmp/pho")
+    7.times do |i|
+      file = File.new( File.join("/tmp/pho", "#{i}.css"), "w" )
+      file.write("CSS#{i}")
+      file.close()
+    end
+    3.times do |i|
+      num = i + 7
+      file = File.new( File.join("/tmp/pho", "#{num}.js"), "w" )
+      file.write("JS#{num}")
+      file.close()
+    end
+    4.times do |i|
+      file = File.new( File.join("/tmp/pho", "#{i}.ok"), "w" )
+      file.write("OK")
+      file.close()      
+    end
+    3.times do |i|
+      num = 4 + i
+      file = File.new( File.join("/tmp/pho", "#{num}.fail"), "w" )
+      file.write("FAIL")
+      file.close()      
+    end        
+  end
+  
+  def teardown()
+    Dir.glob("/tmp/pho/*.css") do |file|
+      File.delete(file)
+    end
+    Dir.glob("/tmp/pho/*.js") do |file|
+      File.delete(file)
+    end    
+    Dir.glob("/tmp/pho/*.ok") do |file|
+      File.delete(file)
+    end
+    Dir.glob("/tmp/pho/*.fail") do |file|
+      File.delete(file)
+    end        
+  end
+      
+  def test_new_files()
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
+    collection = Pho::FileManagement::FileManager.new(store, "/tmp/pho")
+
+    newfiles = collection.new_files()
+    newfiles.sort!
+    assert_equal(3, newfiles.size)
+    assert_equal("/tmp/pho/7.js", newfiles[0])    
+    assert_equal("/tmp/pho/8.js", newfiles[1])
+    assert_equal("/tmp/pho/9.js", newfiles[2])
+        
+  end        
+
+  def test_store()
+      mc = mock()
+      mc.expects(:set_auth)
+      #mc.stub_everything()      
+      mc.expects(:post).with("http://api.talis.com/stores/testing/items", "JS7", {"Content-Type" => "application/javascript"}).returns( HTTP::Message.new_response("OK"))
+      mc.expects(:post).with("http://api.talis.com/stores/testing/items", "JS8", {"Content-Type" => "application/javascript"}).returns( HTTP::Message.new_response("OK"))
+      mc.expects(:post).with("http://api.talis.com/stores/testing/items", "JS9", {"Content-Type" => "application/javascript"}).returns( HTTP::Message.new_response("OK"))
+      
+      store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)      
+      collection = Pho::FileManagement::FileManager.new(store, "/tmp/pho")
+      collection.store()
+      
+      assert_equal(true, File.exists?("/tmp/pho/7.ok") )      
+      assert_equal(true, File.exists?("/tmp/pho/8.ok") )
+      assert_equal(true, File.exists?("/tmp/pho/9.ok") )
+      
+  end
+  
+  def test_list()
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
+    collection = Pho::FileManagement::FileManager.new(store, "/tmp/pho")
+
+    files = collection.list()
+    assert_equal(10, files.size)    
+  end
+              
+end