rdf_context 0.4.8 → 0.5.0

data/lib/rdf_context/namespace.rb

@@ -1,7 +1,7 @@
 module RdfContext
   # From RdfContext
   class Namespace
-    attr_accessor :prefix, :uri, :fragment
+    attr_accessor :prefix, :fragment
  
     ## 
     # Creates a new namespace given a URI and the prefix.
@@ -19,14 +19,17 @@ module RdfContext
     # @author Tom Morris, Pius Uzamere
     def initialize(uri, prefix, fragment = nil)
       prefix = prefix.to_s
-      @uri = URIRef.new(uri) unless uri.is_a?(URIRef)
+
       @fragment = fragment
-      @fragment = uri.to_s.match(/\#$/) ? true : false if fragment.nil?
-      if prefix_valid?(prefix)
-        @prefix = prefix
-      else
-        raise ParserException, "Invalid prefix '#{prefix}'"
+      if uri.to_s.match(/^(.*)\#$/)
+        # Remove frag hash from URI so URIRef doesn't screw it up
+        uri = $1
+        @fragment ||= true
       end
+      @uri = uri.is_a?(URIRef) ? uri : URIRef.new(uri, :normalize => false, :namespace => self)
+
+      raise ParserException, "Invalid prefix '#{prefix}'" unless prefix_valid?(prefix)
+      @prefix = prefix
     end
 
     ## 
@@ -45,14 +48,22 @@ module RdfContext
       self + methodname
     end
 
-    # Construct a URIRef from a namespace as in method_missing, but without method collision issues
+    # Construct a URIRef from a namespace as in method_missing, but without method collision issues.
+    # Rules are somewhat different than for normal URI unions, as the raw URI is used as the source,
+    # not a normalized URI, and the result is not normalized
     def +(suffix)
       prefix = @uri.to_s
-      prefix += '#' if fragment && !prefix.match(/\#$/)
+      prefix += '#' if @fragment && !prefix.index("#")
+      suffix = suffix.to_s.sub(/^\#/, "") if prefix.index("#")
       suffix = suffix.to_s.sub(/_$/, '')
-      URIRef.new(prefix + suffix)
+      URIRef.new(prefix + suffix, :normalize => false, :namespace => self)
     end
 
+    # Make sure to attach fragment
+    def uri
+      self + ""
+    end
+    
     # Bind this namespace to a Graph
     def bind(graph)
       graph.bind(self)
@@ -60,7 +71,7 @@ module RdfContext
 
     # Compare namespaces
     def eql?(other)
-      @prefix == other.prefix && @uri == other.uri && @fragment == other.fragment
+      @prefix == other.prefix && self.uri == other.uri && @fragment == other.fragment
     end
     alias_method :==, :eql?
 
@@ -75,7 +86,7 @@ module RdfContext
     end
     
     def inspect
-      "Namespace[abbr='#{prefix}',uri='#{uri}']"
+      "Namespace[abbr='#{prefix}',uri='#{@uri}']"
     end
     
     private

data/lib/rdf_context/parser.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(__FILE__), 'graph')
 module RdfContext
   # Generic RdfContext Parser class
   class Parser
-    attr_reader :debug
+    attr_reader :debug, :uri
     attr_accessor :doc, :graph
 
     ## 
@@ -72,7 +72,7 @@ module RdfContext
         @delegate.parse(stream, uri, options, &block)
       else
         # Common parser operations
-        @uri = Addressable::URI.parse(uri.to_s).to_s unless uri.nil?
+        @uri = URIRef.new(uri.to_s) unless uri.nil?
         @strict = options[:strict] if options.has_key?(:strict)
         @debug = options[:debug] if options.has_key?(:debug)
         
@@ -93,6 +93,7 @@ module RdfContext
 
     # Heuristically detect the format of the uri
     def detect_format(stream, uri = nil)
+      uri ||= stream.path if stream.respond_to?(:path)
       format = case uri.to_s
       when /\.(rdf|xml)$/      then :rdfxml
       when /\.(html|xhtml)$/   then :rdfa
@@ -131,7 +132,7 @@ module RdfContext
     # @param [String] message::
     def add_debug(node, message)
       puts "#{node_path(node)}: #{message}" if $DEBUG
-      @debug << "#{node_path(node)}: #{message}" if @debug
+      @debug << "#{node_path(node)}: #{message}" if @debug.is_a?(Array)
     end
 
     # add a triple, object can be literal or URI or bnode

data/lib/rdf_context/quoted_graph.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), "graph")
+
+module RdfContext
+  # QuotedGraph - Supports N3 Formulae.
+  #
+  # QuotedGraphs behave like other graphs, except that the triples are not considered for inference rules
+  # and their statements are not held has _truth_. Triples from a QuotedGraph are not returned from
+  # a ConjunctiveGraph in the same store space.
+  #
+  # Within N3, a QuotedGraph is represented as a set of statements contained between _{_ and _}_
+  #
+  #   { [ x:firstname  "Ora" ] dc:wrote [ dc:title  "Moby Dick" ] } a n3:falsehood .
+  class QuotedGraph < Graph
+    ## 
+    # Adds one or more extant triples to a graph. Delegates to Store.
+    #
+    # ==== Example
+    #   g = Graph.new;
+    #   t1 = Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new);
+    #   t2 = Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new);
+    #   g.add(t1, t2, ...)
+    #
+    # @param [Triple] triples:: one or more triples. Last element may be a hash for options
+    # <em>options[:context]</em>:: Graph context in which to deposit triples, defaults to default_context or self
+    # @return [Graph]:: Returns the graph
+    def add(*triples)
+      options = triples.last.is_a?(Hash) ? triples.pop : {}
+      ctx = options[:context] || @default_context || self
+      triples.each {|t| @store.add(t, ctx, true)}
+      self
+    end
+    
+    # Return an n3 identifier for the Graph
+    def n3
+      "{#{self.identifier.to_n3}}"
+    end
+  end
+end

data/lib/rdf_context/rdfaparser.rb

@@ -95,6 +95,7 @@ module RdfContext
         base = base_el.attributes['href']
         # Strip any fragment from base
         base = base.to_s.split("#").first
+        @uri = URIRef.new(base)
         add_debug(base_el, "parse_whole_doc: base='#{base}'")
       end
 
@@ -372,7 +373,7 @@ module RdfContext
         # we force a non-nil name, otherwise it generates a new name
         BNode.new(suffix || "", @named_bnodes)
       elsif curie.to_s.empty?
-        add_debug(nil, "curie_to_resource_or_bnode #{URIRef.new(subject)}")
+        add_debug(nil, "curie_to_resource_or_bnode #{subject}")
         # Empty curie resolves to current subject (No, an empty curie should be ignored)
 #        URIRef.new(subject)
         nil

data/lib/rdf_context/rdfxmlparser.rb

@@ -66,6 +66,7 @@ module RdfContext
         element.namespaces.each do |attr_name,attr_value|
           abbr, suffix = attr_name.to_s.split(":")
           if abbr == "xmlns"
+            attr_value = URIRef.new(attr_value, self.base) if attr_value.match(/^\#/)
             mappings[suffix] = Namespace.new(attr_value, suffix)
             @graph.bind(mappings[suffix])
           end
@@ -176,7 +177,7 @@ module RdfContext
         if attr.uri == RDF_TYPE
           # If there is an attribute a in propertyAttr with a.URI == rdf:type
           # then u:=uri(identifier:=resolve(a.string-value))
-          # and the following tiple is added to the graph:
+          # and the following triple is added to the graph:
           u = URIRef.new(attr.value, ec.base)
           add_triple(attr, subject, RDF_TYPE, u)
         elsif is_propertyAttr?(attr)
@@ -198,7 +199,7 @@ module RdfContext
         
         # Determine the content type of this property element
         text_nodes = child.children.select {|e| e.text? && !e.blank?}
-        element_nodes = child.children.select(&:element?)
+        element_nodes = child.children.select {|c| c.element? }
         add_debug(child, "#{text_nodes.length} text nodes, #{element_nodes.length} element nodes")
         if element_nodes.length > 1
           element_nodes.each do |node|
@@ -501,7 +502,7 @@ module RdfContext
       if (CORE_SYNTAX_TERMS + [RDF_NS.li.to_s] + OLD_TERMS).include?(el.uri.to_s)
         warn = "Invalid use of rdf:#{el.name}"
         add_debug(el, warn)
-        raise InvalidSubject.new(warn) if @strict
+        raise InvalidNode.new(warn) if @strict
       end
     end
 

data/lib/rdf_context/store/abstract_sql_store.rb

@@ -492,7 +492,7 @@ module RdfContext
         id, termComb = row
 
         termCombString = REVERSE_TERM_COMBINATIONS[termComb.to_i]
-        subjTerm, predTerm, objTerm, ctxTerm = termCombString.chars.to_a
+        subjTerm, predTerm, objTerm, ctxTerm = termCombString.scan(/./)
 
         graphKlass, idKlass = constructGraph(ctxTerm)
         [graphKlass, idKlass.new(id)]
@@ -846,7 +846,7 @@ module RdfContext
 
       context = rtContext || hardCodedContext
       termCombString = REVERSE_TERM_COMBINATIONS[termComb.to_i]
-      subjTerm, predTerm, objTerm, ctxTerm = termCombString.chars.to_a
+      subjTerm, predTerm, objTerm, ctxTerm = termCombString.scan(/./)
       
       s = createTerm(subject, subjTerm)
       p = createTerm(predicate, predTerm)
@@ -862,8 +862,8 @@ module RdfContext
       case termType
       when "L"
         @literalCache[[termString, objLanguage, objDatatype]] ||= Literal.n3_encoded(termString, objLanguage, objDatatype)
-#      when "F"
-#        @otherCache[[termType, termString]] ||= QuotedGraph(:identifier => URIRef(termString), :store => self)
+      when "F"
+        @otherCache[[termType, termString]] ||= QuotedGraph(:identifier => URIRef(termString), :store => self)
       when "B"
         @bnodeCache[termString] ||= begin
           bn = BNode.new

data/lib/rdf_context/store/abstract_store.rb

@@ -38,7 +38,7 @@ module RdfContext
       uri = namespace.uri.to_s
       @uri_binding[uri] = namespace unless namespace.prefix.to_s.empty?
       @uri_binding[uri] ||= namespace
-      @nsbinding[namespace.prefix.to_s] ||= namespace
+      @nsbinding[namespace.prefix.to_s] = namespace
     end
 
     # Namespace for prefix
@@ -59,6 +59,10 @@ module RdfContext
           bn[t.subject] ||= 0
           bn[t.subject] += 1
         end
+        if t.predicate.is_a?(BNode)
+          bn[t.predicate] ||= 0
+          bn[t.predicate] += 1
+        end
         if t.object.is_a?(BNode)
           bn[t.object] ||= 0
           bn[t.object] += 1

data/lib/rdf_context/store/sqlite3_store.rb

@@ -92,13 +92,14 @@ module RdfContext
 
     # Where clase utility functions
     def buildSubjClause(subject, tableName)
-  #    case subject
+      case subject
   #    when REGEXTerm
   #    when Array
-  #    when QuotedGraph
-  #    else
+      when Graph
+         ["#{tableName}.subject=?", self.normalizeTerm(subject.identifier)]
+      else
         ["#{tableName}.subject=?", subject] if subject
-  #    end
+      end
     end
 
     def buildPredClause(predicate, tableName)
@@ -112,13 +113,14 @@ module RdfContext
 
     # Where clase utility functions
     def buildObjClause(object, tableName)
-  #    case object
+      case object
   #    when REGEXTerm
   #    when Array
-  #    when QuotedGraph
-  #    else
+    when Graph
+      ["#{tableName}.object=?", self.normalizeTerm(object.identifier)]
+      else
         ["#{tableName}.object=?", object] if object
-  #    end
+      end
     end
 
     # Where clase utility functions

data/lib/rdf_context/string_hacks.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require 'iconv'
 
 class String
@@ -41,6 +42,17 @@ class String
     '/'   =>  '/',
   } # :nodoc:
 
+  if defined?(::Encoding)
+    # Funky way to define constant, but if parsed in 1.8 it generates an 'invalid regular expression' error otherwise
+    eval %(ESCAPE_RE = %r([\u{80}-\u{10ffff}]))
+  else
+    ESCAPE_RE = %r(
+                    [\xc2-\xdf][\x80-\xbf]    |
+                    [\xe0-\xef][\x80-\xbf]{2} |
+                    [\xf0-\xf4][\x80-\xbf]{3}
+                  )nx
+  end
+  
   # Convert a UTF8 encoded Ruby string _string_ to an escaped string, encoded with
   # UTF16 big endian characters as \U????, and return it.
   #
@@ -54,21 +66,20 @@ class String
   # \U00hhhhhh:: character in plane 1-16 with Unicode value U+hhhhhh
   def rdf_escape
     string = self + '' # XXX workaround: avoid buffer sharing
-    string.force_encoding(Encoding::ASCII_8BIT) if String.method_defined?(:force_encoding)
     string.gsub!(/["\\\/\x0-\x1f]/) { RDF_MAP[$&] }
-    string.gsub!(/(
-                    (?:
-                      [\xc2-\xdf][\x80-\xbf]    |
-                      [\xe0-\xef][\x80-\xbf]{2} |
-                      [\xf0-\xf4][\x80-\xbf]{3}
-                    )+ |
-                    [\x80-\xc1\xf5-\xff]       # invalid
-                  )/nx) { |c|
-                    c.size == 1 and raise TypeError, "invalid utf8 byte: '#{c}'"
-                    s = Iconv.new('utf-16be', 'utf-8').iconv(c).unpack('H*')[0].upcase
-                    s.gsub!(/.{4}/n, '\\\\u\&')
-                  }
-    string.force_encoding(Encoding::UTF_8) if String.method_defined?(:force_encoding)
+    if defined?(::Encoding)
+      string.force_encoding(Encoding::UTF_8)
+      string.gsub!(ESCAPE_RE) { |c|
+                      s = c.dump.sub(/\"\\u\{(.+)\}\"/, '\1').upcase
+                      (s.length <= 4 ? "\\u0000"[0,6-s.length] : "\\U00000000"[0,10-s.length]) + s
+                    }
+      string.force_encoding(Encoding::ASCII_8BIT)
+    else
+      string.gsub!(ESCAPE_RE) { |c|
+                      s = Iconv.new('utf-16be', 'utf-8').iconv(c).unpack('H*').first.upcase
+                      "\\u" + s
+                    }
+    end
     string
   end
   
@@ -86,21 +97,33 @@ class String
     ?u  => nil, 
   })
 
+  if defined?(::Encoding)
+    UNESCAPE_RE = %r(
+      (?:\\[\\bfnrt"/])   # Escaped control characters, " and /
+      |(?:\\U00\h{6})     # 6 byte escaped Unicode
+      |(?:\\u\h{4})       # 4 byte escaped Unicode
+    )xn
+  else
+    UNESCAPE_RE = %r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n
+  end
+  
   # Reverse operation of escape
   # From JSON parser
   def rdf_unescape
     return '' if self.empty?
-    string = self.gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
-      if u = RDF_UNESCAPE_MAP[$&[1]]
-        u
-      else # \uXXXX
+    string = self.gsub(UNESCAPE_RE) do |c|
+      case c[1,1]
+      when 'U'
+        raise RdfException, "Long Unicode escapes no supported in Ruby 1.8" unless defined?(::Encoding)
+        eval(c.sub(/\\U00(\h+)/, '"\u{\1}"'))
+      when 'u'
         bytes = [c[2, 2].to_i(16), c[4, 2].to_i(16)]
         Iconv.new('utf-8', 'utf-16').iconv(bytes.pack("C*"))
+      else
+        RDF_UNESCAPE_MAP[c[1]]
       end
     end
-    if string.respond_to?(:force_encoding)
-      string.force_encoding(Encoding::UTF_8)
-    end
+    string.force_encoding(Encoding::UTF_8) if defined?(::Encoding)
     string
   rescue Iconv::Failure => e
     raise RdfException, "Caught #{e.class}: #{e}"

data/lib/rdf_context/term_utils.rb

@@ -12,7 +12,7 @@ module RdfContext
     }
 
     GRAPH_TERM_DICT = {
-        #'F' => [QuotedGraph, URIRef],
+        'F' => [QuotedGraph, URIRef],
         'U' => [Graph, URIRef],
         'B' => [Graph, BNode]
     }
@@ -150,6 +150,72 @@ module RdfContext
         'FVFU' => 118,
         'FVFB' => 119,
         'FVFF' => 120,
+
+        # BNode predicates
+        'UBUU' => 121,
+        'UBUB' => 122,
+        'UBUF' => 123,
+        'UBVU' => 124,
+        'UBVB' => 125,
+        'UBVF' => 126,
+        'UBBU' => 127,
+        'UBBB' => 128,
+        'UBBF' => 129,
+        'UBLU' => 130,
+        'UBLB' => 131,
+        'UBLF' => 132,
+        'UBFU' => 133,
+        'UBFB' => 134,
+        'UBFF' => 135,
+
+        'VBUU' => 136,
+        'VBUB' => 137,
+        'VBUF' => 138,
+        'VBVU' => 139,
+        'VBVB' => 140,
+        'VBVF' => 141,
+        'VBBU' => 142,
+        'VBBB' => 143,
+        'VBBF' => 144,
+        'VBLU' => 145,
+        'VBLB' => 146,
+        'VBLF' => 147,
+        'VBFU' => 148,
+        'VBFB' => 149,
+        'VBFF' => 150,
+
+        'BBUU' => 151,
+        'BBUB' => 152,
+        'BBUF' => 153,
+        'BBVU' => 154,
+        'BBVB' => 155,
+        'BBVF' => 156,
+        'BBBU' => 157,
+        'BBBB' => 158,
+        'BBBF' => 159,
+        'BBLU' => 160,
+        'BBLB' => 161,
+        'BBLF' => 162,
+        'BBFU' => 163,
+        'BBFB' => 164,
+        'BBFF' => 165,
+
+        'FBUU' => 166,
+        'FBUB' => 167,
+        'FBUF' => 168,
+        'FBVU' => 169,
+        'FBVB' => 170,
+        'FBVF' => 171,
+        'FBBU' => 172,
+        'FBBB' => 173,
+        'FBBF' => 174,
+        'FBLU' => 175,
+        'FBLB' => 176,
+        'FBLF' => 177,
+        'FBFU' => 178,
+        'FBFB' => 179,
+        'FBFF' => 180,
+
     }
 
     REVERSE_TERM_COMBINATIONS = TERM_COMBINATIONS.invert
@@ -157,9 +223,12 @@ module RdfContext
     # Takes an instance of a Graph (Graph, QuotedGraph, ConjunctiveGraph)
     # and returns the Graphs identifier and 'type' ('U' for Graphs, 'F' for QuotedGraphs ).
     def normalizeGraph(graph)
-      t = #graph.is_a?(QuotedGraph) ? "F" : term2Letter(graph.identifier)
+      t = case graph
+      when QuotedGraph  then "F"
+      when Graph        then term2Letter(graph.identifier)
+      else                   term2Letter(graph)
+      end
       identifier = graph.respond_to?(:identifier) ? graph.identifier : graph
-      t = term2Letter(identifier)
       [identifier, t]
     end
     
@@ -168,7 +237,7 @@ module RdfContext
       when URIRef       then "U"
       when BNode        then "B"
       when Literal      then "L"
-      #when QuotedGraph  then "F"
+      when QuotedGraph  then "F"
       #when Variable     then "V"
       when Graph        then term2Letter(term.identifier)
       when nil          then "L"