talia_core 0.5.4 → 0.7.0

data/lib/talia_util/xml/base_builder.rb

@@ -7,7 +7,34 @@ module TaliaUtil
     # All builders will be used through the #open method, which can be passed either a Builder::XmlMarkup
     # object, or the options to create one.
     #
-    # Subclasses must provide a build_structure method that creates the outer structure of the XML
+    # Subclasses must provide a method named "build_structure" method. The method must accept a block,
+    # and should create the outer structure of the XML document and yield to the block to build the
+    # inner content.
+    #
+    # = Example:
+    #
+    #  class ABuilder < BaseBuilder
+    #   
+    #    def build_structure
+    #      @builder.div { yield }
+    #    end
+    #   
+    #    def write_stuff(text)
+    #      @builder.p { @builder.text!(text) }
+    #    end  
+    #  end
+    #
+    #  xml = ABuilder.make_xml_string do |builder|
+    #     builder.write_stuff("Hello")
+    #     builder.write_stuff("world")
+    #  end
+    #
+    # Which would result in:
+    #
+    #  <div>
+    #    <p>Hello</p>
+    #    <p>World</p>
+    #  </div>
     class BaseBuilder
       
       # Creates a new builder. The options are equivalent for the options of the

data/lib/talia_util/xml/rdf_builder.rb

@@ -1,6 +1,30 @@
 module TaliaUtil
   module Xml
-    # Class for creating xml-rdf data
+    # Extends the BaseBuilder to allow for easy writing of xml-rdf data. This can
+    # be used in a very self-contained way, by simply passing the triples to write
+    # out to the #open_for_triples or #xml_string_for_triples methods. 
+    #
+    # If those self-contained methods are used the, builder will also "group" the
+    # rdf triples, by including all relations for a single subjects in a single tag,
+    # etc.
+    #
+    # Each triple is expected to be an array of 3 elements, for subject, predicate
+    # and object. Multiple triples are passed as an array of such arrays.
+    #
+    # It is also possible to create a builder manually and use the #write_triple
+    # inside.
+    # 
+    # The resulting XML will contain namespace definitions for all namespaces 
+    # currently known by N::Namespace. 
+    #
+    # If the self-contained writer methods is used, it will also build namespace 
+    # definitions for all predicates (so that each predicate is expressed as 
+    # namespace:name).
+    #
+    # The namespaces for predicates are not built when using write 
+    # methods like write_triple directly. In that case a predicate that is
+    # outside a known namespace would cause an invalid xml-rdf, as predicates
+    # must not be expressed as full URIs in that format.
     class RdfBuilder < BaseBuilder
 
       # Writes a simple "flat" triple. If the object is a string, it will be
@@ -24,7 +48,9 @@ module TaliaUtil
         end
       end
       
-      # 
+      # Opens a new builder with the given options (see BaseBuilder.open) and
+      # writes all the triples given into an xml-rdf document. This will 
+      # try to intelligently group the tags to make the result more compact.
       def self.open_for_triples(triples, options = nil)
         my_builder = self.new(options)
         
@@ -36,6 +62,8 @@ module TaliaUtil
       end
       
 
+      # Same as open_for_triples, but writes into a string and returns that
+      # string.
       def self.xml_string_for_triples(triples)
         xml = ''
         open_for_triples(triples, :target => xml, :indent => 2)
@@ -44,7 +72,19 @@ module TaliaUtil
 
       private 
       
-      
+      # "Prepares" all the triples into a hash of hashes. This will take the triples
+      # and build a hash which has all subjects as keys. The value for each subject
+      # will be another hash that has all predicates as keys. The value for each
+      # predicate will be an array with all object values for the triple.
+      #
+      # = Pseudo-Example:
+      #  # Input:
+      #  [["subject", "predicate1", "value"], ["subject", "predicate2", "value2"], ["subject", "predicate2", "value3"]]
+      #  # Output:
+      #  {
+      #    "subject" => { "predicate1" => ["value", "value2"], "predicate2" => ["value3"] }
+      #  }
+      #
       def prepare_triples(triples)
         triple_hash = {}
         triples.each do |triple|
@@ -63,7 +103,8 @@ module TaliaUtil
         triple_hash
       end
       
-      # Write for the open_for_triples
+      # Special writer that takes a hash of triples that is produced by #prepare_triples
+      # and writes it out to the XML document.
       def write_for_triples(triple_hash)
         triple_hash.each do |subject, values|
           @builder.rdf :Description, 'rdf:about' => subject.to_uri.to_name_s do # Element describing this resource
@@ -74,6 +115,12 @@ module TaliaUtil
         end
       end
       
+      # This is used to make a namespace for a given predicate. It splits
+      # the URI using #split_uri! and passes the "namespace" part of the 
+      # URI to #make_namespace to create a symbolic name for it.
+      #
+      # The method returns the uri of the predicate in a "namespace:local_name"
+      # notation.
       def make_predicate_namespace(predicate)
         pred_uri = URI.parse(predicate.to_s)
         path_parts = split_uri!(pred_uri)
@@ -82,6 +129,12 @@ module TaliaUtil
         "#{namespace}:#{path_parts[1]}"
       end
 
+
+      # Split a URI into a namespace part and local part. The local part
+      # is either the fragment (part after the # character), or the part
+      # after the last forward slash.
+      #
+      # This method needs an URI object from the standard ruby library.
       def split_uri!(uri)
         if(uri.fragment)
           fragment = uri.fragment
@@ -94,6 +147,15 @@ module TaliaUtil
         end
       end
 
+      # Create a namespace from a given uri. The method creates a 
+      # symbolic name for the namespace from the uri; it will try to
+      # create a "readable" result. 
+      #
+      # The method checks all the previously created namespaces, in case
+      # of a name collision, a number is added to the namespace name.
+      # 
+      # All newly created namespaces are added to a hash that can be
+      # accessed with #additional_namespaces
       def make_namespace(namespace_uri)
         candidate = /([^\.]+)(\.[^\.]*)?\Z/.match(namespace_uri.host)[1]
         raise(ArgumentError, "Illegal namespace #{namespace_uri.to_s}") if(candidate.blank?)
@@ -117,16 +179,27 @@ module TaliaUtil
         end
       end
       
+      # Automatically created namespaces for predicates as a hash. Namespaces
+      # are added when they are created using the #make_namespace method.
       def additional_namespaces
         @additional_namespaces ||= {}
       end
       
+      # Returns all namespaces configured in N::Namespace and adds the
+      # #additional_namespaces to the result
+      #
+      # Returns a hash where the keys are the xmlns namespace name and the values are
+      # the namespace URIs
       def namespaces
         namespaces = self.class.namespaces
         additional_namespaces.each { |key, value| namespaces["xmlns:#{key.to_s}"] = value.to_s }
         namespaces
       end
 
+      # Returns all namespaces configured in N::Namespace
+      #
+      # Returns a hash where the keys are the xmlns namespace name and the values are
+      # the namespace URIs
       def self.namespaces
         @namespaces ||= begin
           namespaces = {}
@@ -135,11 +208,14 @@ module TaliaUtil
         end
       end
 
-      # Build an rdf/xml string for one predicate, with the given values
+      # Build an rdf/xml string for one predicate, with the given values. This is the
+      # same as #write_single_predicate for multiple values.
       def write_predicate(predicate, values, check_predicate = true)
         values.each { |val| write_single_predicate(predicate, val, check_predicate) }
       end # end method
 
+      # Writes a single predicate with the given value. When check_predicate is set, this
+      # will raise an error if the predicate cannot be represented as "namespace:name"
       def write_single_predicate(predicate, value, check_predicate = true)
         is_property = value.respond_to?(:uri)
         value_properties = is_property ? { 'value' => value } : extract_values(value.to_s)

data/lib/tasks/talia_core_tasks.rake

@@ -0,0 +1,2 @@
+$: << File.join(File.dirname(__FILE__), '..')
+require 'talia_util/rake_tasks'

data/test/core_ext/boolean_test.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'core_ext', 'boolean')
+
+class BooleanTest < Test::Unit::TestCase
+  
+  def test_true_yes
+    assert(true.yes?)
+    assert(true.true?)
+  end
+  
+  def test_true_no
+    assert(!true.no?)
+    assert(!true.false?)
+  end
+  
+  def test_false_yes
+    assert(!false.yes?)
+    assert(!false.true?)
+  end
+  
+  def test_false_no
+    assert(false.no?)
+    assert(false.false?)
+  end
+  
+end

data/test/core_ext/nil_class_test.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'core_ext', 'nil_class')
+
+class NilClassTest < Test::Unit::TestCase
+  
+  def test_yes
+    assert(!nil.yes?)
+  end
+  
+  def test_no
+    assert(nil.no?)
+  end
+  
+end

data/test/core_ext/object_test.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'core_ext', 'object')
+
+class ObjectTest < Test::Unit::TestCase
+
+  def test_try_call_on_existing
+    assert_equal('abc', 'abc'.try_call.to_s)
+  end
+  
+  def test_try_call_on_not_existing
+    assert_nothing_raised do
+      assert_equal(nil, 'abc'.try_call.foo)
+    end
+  end
+  
+  def test_try_call_on_existing_alternative
+    assert_equal('abc', 'abc'.try_call(:to_s))
+  end
+  
+  def test_try_call_on_not_existing_alternative
+    assert_nothing_raised do
+      assert_equal(nil, 'abc'.try_call(:foo))
+    end
+  end
+  
+end

data/test/core_ext/string_test.rb

@@ -13,4 +13,15 @@ class StringTest < Test::Unit::TestCase
     assert_equal(N::URI.new('http://foo-foo.com'), 'http://foo-foo.com'.to_uri)
     assert_kind_of(N::URI, 'foo-foo.com'.to_uri)
   end
+  
+  def test_yes
+    assert(" YeS ".yes?)
+    assert("TRUE".yes?)
+  end
+  
+  def test_no
+    assert("No ".no?)
+    assert("false".no?)
+  end
+  
 end

data/test/swicky/json_encoder_test.rb

@@ -6,43 +6,17 @@ module Swicky
   class JsonEncoderTest < ActiveSupport::TestCase
     
     def setup
-      @encoder = JsonEncoder.new(test_triples)
+      @encoder = ExhibitJson::ItemCollection.new(test_triples)
     end
     
-    def test_make_predicate_local
-      local = @encoder.send(:make_predicate_local, N::TALIA.foobar)
-      assert_equal('foobar', local)
-      assert_equal({ 'foobar' => { 'uri' => N::TALIA.foobar.to_s, 'valueType' => 'item' } }, @encoder.instance_variable_get(:@properties_hash))
+    def test_item_label
+      fake_item = ExhibitJson::Item.new(N::TALIA.item_label_test, @encoder)
+      assert_equal('item_label_test', fake_item.label)
     end
     
-    def test_make_predicate_local_multi
-      @encoder.send(:make_predicate_local, N::TALIA.foobar)
-      @encoder.send(:make_predicate_local, N::LOCAL.foobar)
-      @encoder.send(:make_predicate_local, N::TALIA.foobar)
-      local = @encoder.send(:make_predicate_local, N::RDF.foobar)
-      assert_equal('foobar3', local)
-    end
-    
-    def test_make_type_local
-      local = @encoder.send(:make_type_local, N::TALIA.Foobar)
-      assert_equal('Foobar', local)
-      assert_equal({ 'Foobar' => { 'uri' => N::TALIA.Foobar.to_s } }, @encoder.instance_variable_get(:@types_hash))
-    end
-    
-    def test_build_item
-      item = @encoder.send(:build_item, N::LOCAL.Foo, {
-        N::RDF.type => [ N::TALIA.Foobar ],
-        N::TALIA.hasIt => ['blarg', 'bar'],
-        N::TALIA.strangeThing => ['what'],
-        'label' => 'bar'
-      })
-      assert_equal([{
-        'uri' => N::LOCAL.Foo.to_s,
-        'type' => [ 'Foobar' ],
-        'label' => 'bar',
-        'hasIt' => ['blarg', 'bar'],
-        'strangeThing' => 'what'
-      }], item)
+    def test_make_id
+      fake_item = ExhibitJson::Item.new(N::TALIA.test_make_id, @encoder)
+      assert_equal('test_make_id', @encoder.make_id(fake_item))
     end
     
     def test_to_json
@@ -55,53 +29,88 @@ module Swicky
       {
         "items" => [
           {
+            "label" => 'toplevel',
+            "uri" => "http://toplevel.org/",
+            "id" => "toplevel",
+            "hash" => "h_d11eb7d2122d6af02a9079d975eaec35",
+            "type" => [ "MyType" ]
+          },
+          { 
+            "label"=>"foobar",
             "uri"=>N::LOCAL.foobar.to_s, 
+            "id"=>"foobar",
+            "hash"=>digest(N::LOCAL.foobar.to_s),
             "type"=>["MyType"], 
             "label"=>"foobar",
             "first"=>["worksit", "worksit2"]
           }, 
           {
-            "uri"=>N::TALIA.whatever.to_s, 
-            "type"=>["Resource"], 
             "label"=>"whatever",
-            "predicate"=>"The cool thing", 
-            "first2"=>"The cool thing"
+            "uri"=>N::TALIA.whatever.to_s, 
+            "id"=>"whatever",
+            "hash"=>digest(N::TALIA.whatever.to_s),
+            "type"=>["Resource"],
+            "predicate"=>"fun", 
+            "first2"=>"fun"
           },
           {
+            "label"=>"The cool thing",
             "uri"=>"http://www.barbaa.com/fun",
+            "id"=>"fun",
+            "hash"=>digest("http://www.barbaa.com/fun"),
             "type"=>["Resource"],
-            "label"=>"The cool thing",
             "predicate"=>"whatever"
           }
         ], 
         "types" => {
           "MyType"=>
           {
-            "uri"=>N::TALIA.MyType.to_s
+            "label"=>"MyType",
+            "uri"=>N::TALIA.MyType.to_s,
+            "id"=>"MyType",
+            "hash"=>digest(N::TALIA.MyType.to_s)
           }, 
           "Resource"=> {
-            "uri"=>"http://www.w3.org/1999/02/22-rdf-syntax-ns#Resource"
+            "label"=>"Resource",
+            "uri"=>"http://www.w3.org/1999/02/22-rdf-syntax-ns#Resource",
+            "id"=>"Resource",
+            "hash"=>digest("http://www.w3.org/1999/02/22-rdf-syntax-ns#Resource")
           }
         }, 
         "properties"=> {
           "first"=> {
+            "label"=>"first",
             "uri"=>"http://www.foobar.com/bar/moo/first", 
-            "valueType"=>"item"
+            "id"=>"first",
+            "hash"=>digest("http://www.foobar.com/bar/moo/first"),
+            "valueType"=>"text"
           }, 
           "predicate"=>{
+            "label"=>"predicate",
             "uri"=>N::TALIA.predicate.to_s, 
+            "id"=>"predicate",
+            "hash"=>digest(N::TALIA.predicate.to_s),
             "valueType"=>"item"
           }, 
           "first2"=>{
-            "uri"=>"http://www.foobar.com/bar/moo#first", "valueType"=>"item"
+            "label"=>"first",
+            "uri"=>"http://www.foobar.com/bar/moo#first", 
+            "id"=>"first2",
+            "hash"=>digest("http://www.foobar.com/bar/moo#first"),
+            "valueType"=>"item"
           }
         }
       }
     end
     
     
+    def digest(value)
+      ('h_' << Digest::MD5.hexdigest(value))
+    end
+    
     def test_triples
       [
+        [ 'http://toplevel.org/', N::RDF.type, N::TALIA.MyType ],
         [ N::LOCAL.foobar, 'http://www.foobar.com/bar/moo/first', "worksit"],
         [ N::LOCAL.foobar, 'http://www.foobar.com/bar/moo/first', "worksit2"],
         [ N::LOCAL.foobar, N::RDF.type, N::TALIA.MyType ],

data/test/swicky/notebook_test.rb

@@ -11,6 +11,7 @@ module Swicky
       setup_once(:flush) { TaliaCore::TestHelper::flush_store }
       @notebook = Notebook.new('dan', 'booky')
       @testpointer = "http://dbin.org/swickynotes/demo/HanselAndGretel.htm#xpointer(start-point(string-range(//DIV[@id='http://dbin.org/swickynotes/demo/HG_1']/P[1]/SPAN[1]/text()[1],'',0))/range-to(string-range(//DIV[@id='http://dbin.org/swickynotes/demo/HG_1']/P[1]/SPAN[1]/text()[1],'',266)))"
+      @testfragment = "http://discovery-project.eu/ontologies/philoSpace/SourceFragment#ec9796a5349b290a7610763dcbc47af2"
     end
     
     def teardown
@@ -25,6 +26,12 @@ module Swicky
       assert_equal(@notebook.user_url, N::LOCAL + 'users/dan')
     end
     
+    def test_url_from_string
+      nb = Notebook.new('http://foobar.org/')
+      assert_kind_of(N::URI, nb.uri)
+      assert_equal(nb.uri, 'http://foobar.org/'.to_uri)
+    end
+    
     def test_load
       assert_notebook_empty
       load_notebook
@@ -57,12 +64,12 @@ module Swicky
       
     def test_find_all_existing
       load_notebook
-      assert_equal([@notebook.url], Notebook.find_all)
+      assert_equal([Notebook.new(@notebook.url)], Notebook.find_all)
     end
       
     def test_find_all_user
       load_notebook
-      assert_equal([@notebook.url], Notebook.find_all('dan'))
+      assert_equal([Notebook.new(@notebook.url)], Notebook.find_all('dan'))
     end
     
     def test_find_all_user_nonexistent
@@ -73,17 +80,17 @@ module Swicky
     def test_get_coordinates
       load_notebook
       coords = Notebook.coordinates_for("http://dbin.org/swickynotes/demo/HanselAndGretel.htm")
-      assert_equal([ @testpointer ], coords)
+      assert_equal([{"fragment" => @testfragment, "coordinates" => @testpointer}], coords)
     end
     
     def test_annotations_for_url
       load_notebook
-      assert_equal(180, Notebook.annotations_for_url("http://discovery-project.eu/ontologies/philoSpace/SourceFragment#ec9796a5349b290a7610763dcbc47af2").size)
+      assert_equal(135, Notebook.annotations_for_url("http://discovery-project.eu/ontologies/philoSpace/SourceFragment#ec9796a5349b290a7610763dcbc47af2").size)
     end
     
     def test_annotations_for_xpointer
       load_notebook
-      assert_equal(180, Notebook.annotations_for_xpointer(@testpointer).size)
+      assert_equal(135, Notebook.annotations_for_xpointer(@testpointer).size)
     end
     
     private
@@ -104,4 +111,4 @@ module Swicky
     
   end
   
-end
+end