pho 0.5 → 0.6

data/lib/pho/store.rb

@@ -1,5 +1,7 @@
 module Pho
 
+  require 'pho/sparql'
+  
 #TODO:
 #
 # Conditional deletions
@@ -180,7 +182,7 @@ module Pho
         u = self.build_uri("/services/sparql")    
       end
       
-      sparql_client = Pho::Sparql::SparqlClient.new(u, @client)
+      sparql_client = StoreSparqlClient.new(@self, u, @client)
       sparql_client.supports_rdf_json = true
       sparql_client.supports_sparql_json = true
       
@@ -341,7 +343,12 @@ module Pho
         response = @client.post(u, data, headers)
       else
         if !uri.start_with?(@storeuri)
-          uri = build_uri(uri)
+          if uri.start_with?("/")
+            uri = build_uri("/items#{uri}")
+          else  
+            uri = build_uri("/items/#{uri}")
+          end
+          
         end
         response = @client.put(uri, data, headers)
       end      
@@ -472,4 +479,23 @@ module Pho
     
   end
 
+  class StoreSparqlClient < Pho::Sparql::SparqlClient
+     
+    def initialize(store, endpoint, client=HTTPClient.new() )
+      super(endpoint, client)
+      @store = store
+    end
+
+    #Override default behaviour to use the Stores Describe service instead
+    #when requesting CBDs        
+    def describe_uri(uri, format="application/rdf+xml", type=:cbd)
+      if type == :cbd
+        return @store.describe(uri, format)
+      else
+        return super
+      end
+    end
+    
+  end
+  
 end

data/tests/tc_contentbox.rb

@@ -24,6 +24,47 @@ class ContentboxTest < Test::Unit::TestCase
     
   end
 
+  def test_upload_item_to_uri_with_relative
+    mc = mock()
+    mc.expects(:set_auth)
+    mc.expects(:put).with("http://api.talis.com/stores/testing/items/1/2/3", "data", {"Content-Type" => "text/plain"})
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+    f = StringIO.new("data")    
+    resp = store.upload_item(f, "text/plain", "/1/2/3")
+    
+  end
+
+  def test_upload_item_to_uri_with_relative_file
+    mc = mock()
+    mc.expects(:set_auth)
+    mc.expects(:put).with("http://api.talis.com/stores/testing/items/a.txt", "data", {"Content-Type" => "text/plain"})
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+    f = StringIO.new("data")    
+    resp = store.upload_item(f, "text/plain", "/a.txt")
+    
+  end
+    
+  def test_upload_item_to_uri_with_relative2
+    mc = mock()
+    mc.expects(:set_auth)
+    mc.expects(:put).with("http://api.talis.com/stores/testing/items/1/2/3", "data", {"Content-Type" => "text/plain"})
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+    f = StringIO.new("data")    
+    resp = store.upload_item(f, "text/plain", "1/2/3")
+    
+  end
+
+  def test_upload_item_to_uri_with_relative_file2
+    mc = mock()
+    mc.expects(:set_auth)
+    mc.expects(:put).with("http://api.talis.com/stores/testing/items/a.txt", "data", {"Content-Type" => "text/plain"})
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
+    f = StringIO.new("data")    
+    resp = store.upload_item(f, "text/plain", "a.txt")
+    
+  end
+  
+            
   def test_delete
     mc = mock()
     mc.expects(:set_auth)

data/tests/tc_enrichment.rb

@@ -25,12 +25,31 @@ class EnrichmentTest < Test::Unit::TestCase
     mc = mock()
     mc.expects(:query).with( query, "application/rdf+xml" ).returns( HTTP::Message.new_response(RDFXML) )
     
-    enricher = Pho::Enrichment::ResourceEnricher.new(mock_store, mc)
+    enricher = Pho::Enrichment::StoreEnricher.new(mock_store, mc)
     resp = enricher.merge(query) 
     assert_not_nil(resp)
 
   end
 
+  def test_merge_with_block()
+    
+    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::StoreEnricher.new(mock_store, mc)
+    resp = enricher.merge(query) do |resp, data|
+      assert_equal( 200, resp.status )
+      assert_equal( RDFXML, data)
+    end 
+    
+    assert_not_nil(resp)
+
+  end
+    
   def test_merge_with_failed_query()
     
     query = "DESCRIBE <http://www.example.org>"
@@ -41,7 +60,7 @@ class EnrichmentTest < Test::Unit::TestCase
     msg.status = 500
     mc.expects(:query).with( query, "application/rdf+xml" ).returns( msg )
     
-    enricher = Pho::Enrichment::ResourceEnricher.new(mock_store, mc)
+    enricher = Pho::Enrichment::StoreEnricher.new(mock_store, mc)
     assert_raises RuntimeError do        
         results = enricher.merge(query)
     end
@@ -59,7 +78,7 @@ class EnrichmentTest < Test::Unit::TestCase
     mc = mock()
     mc.expects(:query).with( query, "application/rdf+xml" ).returns( HTTP::Message.new_response(RDFXML) )
     
-    enricher = Pho::Enrichment::ResourceEnricher.new(mock_store, mc)
+    enricher = Pho::Enrichment::StoreEnricher.new(mock_store, mc)
     resp = enricher.merge(query) 
     assert_equal(500, resp.status)
     
@@ -75,9 +94,27 @@ class EnrichmentTest < Test::Unit::TestCase
     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) 
+    resp = Pho::Enrichment::StoreEnricher.infer(mock_store, query) 
     assert_not_nil(resp)
 
   end  
+
+  def test_infer_with_block()
+    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::StoreEnricher.infer(mock_store, query) do |resp, data|
+        assert_equal(200, resp.status)
+        assert_equal(RDFXML, data)      
+    end 
     
+    assert_not_nil(resp)
+
+  end        
 end

data/tests/tc_file_manager.rb

@@ -7,6 +7,8 @@ class FileManagerTest < Test::Unit::TestCase
 
   def setup()
     Dir.mkdir("/tmp/pho") unless File.exists?("/tmp/pho")
+    Dir.mkdir("/tmp/pho/a") unless File.exists?("/tmp/pho/a")
+    Dir.mkdir("/tmp/pho/b") unless File.exists?("/tmp/pho/b")
     7.times do |i|
       file = File.new( File.join("/tmp/pho", "#{i}.css"), "w" )
       file.write("CSS#{i}")
@@ -28,7 +30,24 @@ class FileManagerTest < Test::Unit::TestCase
       file = File.new( File.join("/tmp/pho", "#{num}.fail"), "w" )
       file.write("FAIL")
       file.close()      
-    end        
+    end
+
+    #/tmp/pho/a
+    2.times do |i|
+      num = i
+      file = File.new( File.join("/tmp/pho/a", "#{num}.txt"), "w" )
+      file.write("TXT#{num}")
+      file.close()
+    end
+
+    #/tmp/pho/b
+    1.times do |i|
+      num = i
+      file = File.new( File.join("/tmp/pho/b", "#{num}.txt"), "w" )
+      file.write("TXT#{num}")
+      file.close()
+    end
+    
   end
   
   def teardown()
@@ -38,12 +57,15 @@ class FileManagerTest < Test::Unit::TestCase
     Dir.glob("/tmp/pho/*.js") do |file|
       File.delete(file)
     end    
-    Dir.glob("/tmp/pho/*.ok") do |file|
+    Dir.glob("/tmp/pho/**/*.ok") do |file|
       File.delete(file)
     end
-    Dir.glob("/tmp/pho/*.fail") do |file|
+    Dir.glob("/tmp/pho/**/*.fail") do |file|
       File.delete(file)
-    end        
+    end
+    Dir.glob("/tmp/pho/**/*.txt") do |file|
+      File.delete(file)
+    end                    
   end
       
   def test_new_files()
@@ -58,14 +80,31 @@ class FileManagerTest < Test::Unit::TestCase
     assert_equal("/tmp/pho/9.js", newfiles[2])
         
   end        
+  
+  def test_new_files_recursive()
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
+    collection = Pho::FileManagement::FileManager.new(store, "/tmp/pho")
+
+    newfiles = collection.new_files(:recurse)
+    newfiles.sort!
+    
+    assert_equal(6, 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])
+    assert_equal("/tmp/pho/a/0.txt", newfiles[3])
+    assert_equal("/tmp/pho/a/1.txt", newfiles[4])
+    assert_equal("/tmp/pho/b/0.txt", newfiles[5])
+        
+  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"))
+      mc.expects(:put).with("http://api.talis.com/stores/testing/items/7.js", "JS7", {"Content-Type" => "application/javascript"}).returns( HTTP::Message.new_response("OK"))
+      mc.expects(:put).with("http://api.talis.com/stores/testing/items/8.js", "JS8", {"Content-Type" => "application/javascript"}).returns( HTTP::Message.new_response("OK"))
+      mc.expects(:put).with("http://api.talis.com/stores/testing/items/9.js", "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")
@@ -76,6 +115,49 @@ class FileManagerTest < Test::Unit::TestCase
       assert_equal(true, File.exists?("/tmp/pho/9.ok") )
       
   end
+
+  def test_store_with_base()
+      mc = mock()
+      mc.expects(:set_auth)
+      #mc.stub_everything()      
+      mc.expects(:put).with("http://api.talis.com/stores/testing/items/assets/7.js", "JS7", {"Content-Type" => "application/javascript"}).returns( HTTP::Message.new_response("OK"))
+      mc.expects(:put).with("http://api.talis.com/stores/testing/items/assets/8.js", "JS8", {"Content-Type" => "application/javascript"}).returns( HTTP::Message.new_response("OK"))
+      mc.expects(:put).with("http://api.talis.com/stores/testing/items/assets/9.js", "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", "assets")
+      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_store_recursive()
+      mc = mock()
+      mc.expects(:set_auth)
+      #mc.stub_everything()      
+      mc.expects(:put).with("http://api.talis.com/stores/testing/items/7.js", "JS7", {"Content-Type" => "application/javascript"}).returns( HTTP::Message.new_response("OK"))
+      mc.expects(:put).with("http://api.talis.com/stores/testing/items/8.js", "JS8", {"Content-Type" => "application/javascript"}).returns( HTTP::Message.new_response("OK"))
+      mc.expects(:put).with("http://api.talis.com/stores/testing/items/9.js", "JS9", {"Content-Type" => "application/javascript"}).returns( HTTP::Message.new_response("OK"))
+      mc.expects(:put).with("http://api.talis.com/stores/testing/items/a/0.txt", "TXT0", {"Content-Type" => "text/plain"}).returns( HTTP::Message.new_response("OK"))
+      mc.expects(:put).with("http://api.talis.com/stores/testing/items/a/1.txt", "TXT1", {"Content-Type" => "text/plain"}).returns( HTTP::Message.new_response("OK"))
+      mc.expects(:put).with("http://api.talis.com/stores/testing/items/b/0.txt", "TXT0", {"Content-Type" => "text/plain"}).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(:recursive)
+      
+      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") )
+      assert_equal(true, File.exists?("/tmp/pho/a/0.ok") )
+      assert_equal(true, File.exists?("/tmp/pho/a/1.ok") )
+      assert_equal(true, File.exists?("/tmp/pho/b/0.ok") )
+      
+  end
   
   def test_list()
     store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
@@ -85,4 +167,12 @@ class FileManagerTest < Test::Unit::TestCase
     assert_equal(10, files.size)    
   end
               
+  def test_list_recursive()
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
+    collection = Pho::FileManagement::FileManager.new(store, "/tmp/pho")
+
+    files = collection.list(:recurse)
+    assert_equal(13, files.size)
+  end
+  
 end

data/tests/tc_rdf_collection.rb

@@ -4,7 +4,6 @@ require 'test/unit'
 require 'mocha'
 
 #TODO factor out tests for AbstractFileManager
-#TODO alter so we're testing the non-deprecated version of the Class
 class RDFCollectionTest < Test::Unit::TestCase
 
   def setup()
@@ -40,21 +39,36 @@ class RDFCollectionTest < Test::Unit::TestCase
   
   def test_get_fail_file_for()
     store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
-    collection = Pho::RDFCollection.new(store, "/tmp")
+    collection = Pho::FileManagement::RDFManager.new(store, "/tmp")
     
     assert_equal("foo.fail", collection.get_fail_file_for("foo.rdf") )    
   end
-  
+
+  def test_get_fail_file_for_with_ext_in_path()
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
+    collection = Pho::FileManagement::RDFManager.new(store, "/tmp/rdf")
+    
+    assert_equal("/tmp/rdf/foo.fail", collection.get_fail_file_for("/tmp/rdf/foo.rdf") )    
+  end
+    
   def test_get_ok_file_for()
     store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
-    collection = Pho::RDFCollection.new(store, "/tmp")
+    collection = Pho::FileManagement::RDFManager.new(store, "/tmp")
     
     assert_equal("foo.ok", collection.get_ok_file_for("foo.rdf") )    
   end  
 
+  def test_get_ok_file_for_with_ext_in_path()
+    store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
+    collection = Pho::FileManagement::RDFManager.new(store, "/tmp/js")
+    
+    assert_equal("/tmp/js/foo.ok", collection.get_ok_file_for("/tmp/js/foo.js") )    
+  end  
+    
+
   def test_successes()
     store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
-    collection = Pho::RDFCollection.new(store, "/tmp")
+    collection = Pho::FileManagement::RDFManager.new(store, "/tmp")
 
     success = collection.successes()
     success.sort!
@@ -68,7 +82,7 @@ class RDFCollectionTest < Test::Unit::TestCase
 
   def test_failures()
     store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
-    collection = Pho::RDFCollection.new(store, "/tmp")
+    collection = Pho::FileManagement::RDFManager.new(store, "/tmp")
 
     fails = collection.failures()
     fails.sort!
@@ -80,7 +94,7 @@ class RDFCollectionTest < Test::Unit::TestCase
   
   def test_new_files()
     store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
-    collection = Pho::RDFCollection.new(store, "/tmp")
+    collection = Pho::FileManagement::RDFManager.new(store, "/tmp")
 
     newfiles = collection.new_files()
     newfiles.sort!
@@ -99,7 +113,7 @@ class RDFCollectionTest < Test::Unit::TestCase
       mc.expects(:post).with("http://api.talis.com/stores/testing/meta", "RDF9", {"Content-Type" => "application/rdf+xml"}).returns( HTTP::Message.new_response("OK"))
       
       store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)      
-      collection = Pho::RDFCollection.new(store, "/tmp")
+      collection = Pho::FileManagement::RDFManager.new(store, "/tmp")
       collection.store()
       
       assert_equal(true, File.exists?("/tmp/7.ok") )      
@@ -110,7 +124,7 @@ class RDFCollectionTest < Test::Unit::TestCase
   
   def test_reset()
     store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
-    collection = Pho::RDFCollection.new(store, "/tmp")
+    collection = Pho::FileManagement::RDFManager.new(store, "/tmp")
 
     collection.reset()
     newfiles = collection.new_files()
@@ -119,7 +133,7 @@ class RDFCollectionTest < Test::Unit::TestCase
   
   def test_list()
     store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
-    collection = Pho::RDFCollection.new(store, "/tmp")
+    collection = Pho::FileManagement::RDFManager.new(store, "/tmp")
 
     files = collection.list()
     assert_equal(10, files.size)    
@@ -127,9 +141,7 @@ class RDFCollectionTest < Test::Unit::TestCase
   
   def test_summary()
     store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass")
-    collection = Pho::RDFCollection.new(store, "/tmp")
-
-    collection.summary()
+    collection = Pho::FileManagement::RDFManager.new(store, "/tmp")
   end
             
 end

data/tests/tc_rdf_parser.rb

@@ -0,0 +1,37 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'pho'
+require 'test/unit'
+require 'mocha'
+require 'rexml/document'
+
+class RdfParserTest < Test::Unit::TestCase
+  
+  NTRIPLES = <<-EOL
+  <http://www.example.org> <http://www.example.org/ns/resource> <http://www.example.org/page>.
+  EOL
+      
+  def setup()
+    Dir.mkdir("/tmp/pho") unless File.exists?("/tmp/pho")
+    @file = File.new( File.join("/tmp/pho", "test.nt"), "w" )
+    @file.write(NTRIPLES)
+    @file.close()    
+  end
+  
+  def teardown()
+    Dir.glob("/tmp/pho/*.nt") do |file|
+      File.delete(file)
+    end    
+  end
+  
+  def test_parse_ntriples    
+    data = Pho::RDF::Parser.parse_ntriples(@file)
+    assert_not_nil(data)
+    REXML::Document.new(data)    
+  end
+  
+  def test_parse_ntriples_from_string
+    data = Pho::RDF::Parser.parse_ntriples_from_string(NTRIPLES, "http://www.example.org")
+    assert_not_nil(data)
+    REXML::Document.new(data)        
+  end
+end