rdf-n3 0.0.1 → 0.0.2

data/.yardopts

@@ -8,3 +8,4 @@
 -
 AUTHORS
 VERSION
+History.txt

data/History.txt

@@ -1,2 +1,11 @@
+=== 0.0.2
+* N3 parsing and Turtle serialization substantially complete.
+  * A little more work needed on some tests and some lingering issues in RDF.rb to be resolved.
+* Added script/console and script/parse
+* Updates to reader to bring it in line with other readers. Implement uri() and ns() as helper functions for constructing URIs.
+* Literal_normalization to override RDF::Literal.initialize and create Literal#valid?
+* rdf_escape Literals when serializing via to_s
+* Remove trailing "#" from URIs when normalizing.
+
 === 0.0.1
 * First port from RdfContext version 0.5.4

data/README.rdoc

@@ -10,6 +10,8 @@ RDF::N3 is an Notation-3 (n3-rdf) parser for Ruby using the RDF.rb library suite
 RDF::N3 parses Notation-3, Turtle and N-Triples into statements or triples. It also serializes to Turtle.
 
 * Fully compliant N3-rdf parser (N3-rdf level)
+* Also parses Turtle and N-Triples
+* Turtle serializer
 
 Install with 'gem install rdf-n3'
 
@@ -25,8 +27,8 @@ Instantiate a parser and parse source, specifying type and base-URL
   end
 
 == Dependencies
-  * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.1.6)
-  * [Treetop](http://rubygems.org/gems/treetop) (>= 1.4.0) -- For generating parser only, not necessary for runtime
+  * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.2.0)
+  * [Treetop](http://rubygems.org/gems/treetop) (>= 1.4.0)
 
 == Resources:
 * Distiller[http://kellogg-assoc/distiller]

data/Rakefile

@@ -1,4 +1,5 @@
 require 'rubygems'
+require 'yard'
 
 begin
   gem 'jeweler'
@@ -12,10 +13,13 @@ begin
     gemspec.email = "gregg@kellogg-assoc.com"
     gemspec.homepage = "http://github.com/gkellogg/rdf-rdfa"
     gemspec.authors = ["Gregg Kellogg"]
-    gemspec.add_dependency('rdf', '>= 0.1.6')
+    gemspec.add_dependency('rdf', '>= 0.2.0')
+    gemspec.add_dependency('treetop',  '>= 1.4.0')
     gemspec.add_development_dependency('rspec')
     gemspec.add_development_dependency('rdf-spec')
-    gemspec.add_development_dependency('treetop',  '>= 1.4.0')
+    gemspec.add_development_dependency('rdf-rdfxml', '>= 0.2.0')
+    gemspec.add_development_dependency('rdf-isomorphic')
+    gemspec.add_development_dependency('yard')
     gemspec.extra_rdoc_files     = %w(README.rdoc History.txt AUTHORS)
   end
   Jeweler::GemcutterTasks.new
@@ -43,4 +47,35 @@ Spec::Rake::SpecTask.new("doc:spec") do |spec|
   spec.spec_opts = ["--format", "html:doc/spec.html"]
 end
 
+YARD::Rake::YardocTask.new do |t|
+  t.files   = %w(lib/**/*.rb README.rdoc History.txt AUTHORS)   # optional
+end
+
+desc "Generate test manifest yaml"
+namespace :spec do
+  task :prepare do
+    $:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+    require 'rdf/rdfxml'
+    require 'rdf/n3'
+    require 'spec/rdf_helper'
+    require 'fileutils'
+
+    yaml = File.join(SWAP_DIR, "n3parser.yml")
+    FileUtils.rm_f(yaml)
+    RdfHelper::TestCase.to_yaml(SWAP_TEST, SWAP_DIR, yaml)
+    
+    yaml = File.join(SWAP_DIR, "regression.yml")
+    FileUtils.rm_f(yaml)
+    RdfHelper::TestCase.to_yaml(CWM_TEST, SWAP_DIR, yaml)
+    
+    yaml = File.join(TURTLE_DIR, "manifest.yml")
+    FileUtils.rm_f(yaml)
+    RdfHelper::TestCase.to_yaml(TURTLE_TEST, TURTLE_DIR, yaml)
+    
+    yaml = File.join(TURTLE_DIR, "manifest-bad.yml")
+    FileUtils.rm_f(yaml)
+    RdfHelper::TestCase.to_yaml(TURTLE_TEST, TURTLE_DIR, yaml)
+  end
+end
+
 task :default => :spec

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/example.rb

@@ -3,7 +3,7 @@
 $:.unshift(File.join(File.dirname(__FILE__), 'lib'))
 
 require 'rubygems'
-require 'rdf/rdfa'
+require 'rdf/n3'
 
 data = <<-EOF;
   @prefix dc: <http://purl.org/dc/elements/1.1/>.

data/lib/rdf/n3.rb

@@ -1,4 +1,4 @@
-$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..')))
 require 'rdf'
 
 module RDF
@@ -20,11 +20,18 @@ module RDF
   #
   # @author [Gregg Kellogg](http://kellogg-assoc.com/)
   module N3
-    require 'n3/format'
-    require 'n3/vocab'
-    require 'n3/patches/array_hacks'
-    require 'n3/patches/rdf_escape'
+    require 'rdf/n3/format'
+    require 'rdf/n3/vocab'
+    require 'rdf/n3/patches/array_hacks'
+    require 'rdf/n3/patches/literal_hacks'
+    require 'rdf/n3/patches/literal_normalization'
+    require 'rdf/n3/patches/graph_properties'
+    require 'rdf/n3/patches/qname_hacks'
+    require 'rdf/n3/patches/rdf_escape'
+    require 'rdf/n3/patches/seq'
+    require 'rdf/n3/patches/uri_hacks'
     autoload :Reader,  'rdf/n3/reader'
     autoload :VERSION, 'rdf/n3/version'
+    autoload :Writer,  'rdf/n3/writer'
   end
 end

data/lib/rdf/n3/format.rb

@@ -4,7 +4,6 @@ module RDF::N3
   #
   # @example Obtaining an RDFa format class
   #   RDF::Format.for(:n3)            #=> RDF::N3::Format
-  #   RDF::Format.for(:ttl)            #=> RDF::N3::Format
   #   RDF::Format.for("etc/foaf.ttl")
   #   RDF::Format.for("etc/foaf.n3")
   #   RDF::Format.for(:file_name      => "etc/foaf.ttl")

data/lib/rdf/n3/patches/array_hacks.rb

@@ -1,131 +1,53 @@
-# coding: utf-8
-require 'iconv'
-
-class String
-  #private
-  # "Borrowed" from JSON utf8_to_json
-  RDF_MAP = {
-    "\x0" => '\u0000',
-    "\x1" => '\u0001',
-    "\x2" => '\u0002',
-    "\x3" => '\u0003',
-    "\x4" => '\u0004',
-    "\x5" => '\u0005',
-    "\x6" => '\u0006',
-    "\x7" => '\u0007',
-    "\b"  =>  '\b',
-    "\t"  =>  '\t',
-    "\n"  =>  '\n',
-    "\xb" => '\u000B',
-    "\f"  =>  '\f',
-    "\r"  =>  '\r',
-    "\xe" => '\u000E',
-    "\xf" => '\u000F',
-    "\x10" => '\u0010',
-    "\x11" => '\u0011',
-    "\x12" => '\u0012',
-    "\x13" => '\u0013',
-    "\x14" => '\u0014',
-    "\x15" => '\u0015',
-    "\x16" => '\u0016',
-    "\x17" => '\u0017',
-    "\x18" => '\u0018',
-    "\x19" => '\u0019',
-    "\x1a" => '\u001A',
-    "\x1b" => '\u001B',
-    "\x1c" => '\u001C',
-    "\x1d" => '\u001D',
-    "\x1e" => '\u001E',
-    "\x1f" => '\u001F',
-    '"'   =>  '\"',
-    '\\'  =>  '\\\\',
-    '/'   =>  '/',
-  } # :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.
-  #
-  # \\:: Backslash
-  # \':: Single quote
-  # \":: Double quot
-  # \n:: ASCII Linefeed
-  # \r:: ASCII Carriage Return
-  # \t:: ASCCII Horizontal Tab
-  # \uhhhh:: character in BMP with Unicode value U+hhhh
-  # \U00hhhhhh:: character in plane 1-16 with Unicode value U+hhhhhh
-  def rdf_escape
-    string = self + '' # XXX workaround: avoid buffer sharing
-    string.gsub!(/["\\\/\x0-\x1f]/) { RDF_MAP[$&] }
-    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)
+class Array
+  # http://wiki.rubygarden.org/Ruby/page/show/ArrayPermute
+  # Permute an array, and call a block for each permutation
+  # Author: Paul Battley
+  def permute(prefixed=[])
+    if (length < 2)
+      # there are no elements left to permute
+      yield(prefixed + self)
     else
-      string.gsub!(ESCAPE_RE) { |c|
-                      s = Iconv.new('utf-16be', 'utf-8').iconv(c).unpack('H*').first.upcase
-                      "\\u" + s
-                    }
+      # recursively permute the remaining elements
+      each_with_index do |e, i|
+        (self[0,i]+self[(i+1)..-1]).permute(prefixed+[e]) { |a| yield a }
+      end
     end
-    string
-  end
+  end unless Array.method_defined?(:permute)
   
-  # Unescape characters in strings.
-  RDF_UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
-  RDF_UNESCAPE_MAP.update({
-    ?"  => '"',
-    ?\\ => '\\',
-    ?/  => '/',
-    ?b  => "\b",
-    ?f  => "\f",
-    ?n  => "\n",
-    ?r  => "\r",
-    ?t  => "\t",
-    ?u  => nil, 
-  })
+  # Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:
+  # * <tt>:words_connector</tt> - The sign or word used to join the elements in arrays with two or more elements (default: ", ")
+  # * <tt>:two_words_connector</tt> - The sign or word used to join the elements in arrays with two elements (default: " and ")
+  # * <tt>:last_word_connector</tt> - The sign or word used to join the last element in arrays with three or more elements (default: ", and ")
+  def to_sentence(options = {})
+    default_words_connector     = ", "
+    default_two_words_connector = " and "
+    default_last_word_connector = ", and "
 
-  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
-    )x
-  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(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*"))
+    # Try to emulate to_senteces previous to 2.3
+    if options.has_key?(:connector) || options.has_key?(:skip_last_comma)
+      ::ActiveSupport::Deprecation.warn(":connector has been deprecated. Use :words_connector instead", caller) if options.has_key? :connector
+      ::ActiveSupport::Deprecation.warn(":skip_last_comma has been deprecated. Use :last_word_connector instead", caller) if options.has_key? :skip_last_comma
+
+      skip_last_comma = options.delete :skip_last_comma
+      if connector = options.delete(:connector)
+        options[:last_word_connector] ||= skip_last_comma ? connector : ", #{connector}"
       else
-        RDF_UNESCAPE_MAP[c[1]]
+        options[:last_word_connector] ||= skip_last_comma ? default_two_words_connector : default_last_word_connector
       end
     end
-    string.force_encoding(Encoding::UTF_8) if defined?(::Encoding)
-    string
-  rescue Iconv::Failure => e
-    raise RdfException, "Caught #{e.class}: #{e}"
-  end
-end unless String.method_defined?(:rdf_escape)
+
+#    options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
+    options = {:words_connector => default_words_connector, :two_words_connector => default_two_words_connector, :last_word_connector => default_last_word_connector}.merge(options)
+
+    case length
+      when 0
+        ""
+      when 1
+        self[0].to_s
+      when 2
+        "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
+      else
+        "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
+    end
+  end unless Array.method_defined?(:to_sentence)
+end

data/lib/rdf/n3/patches/graph_properties.rb

@@ -0,0 +1,34 @@
+module RDF
+  class Graph
+    # Resource properties
+    #
+    # Properties arranged as a hash with the predicate Term as index to an array of resources or literals
+    #
+    # Example:
+    #   graph.load(':foo a :bar; rdfs:label "An example" .', "http://example.com/")
+    #   graph.resources(URI.new("http://example.com/subject")) =>
+    #   {
+    #     "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" => [<http://example.com/#bar>],
+    #     "http://example.com/#label"                       => ["An example"]
+    #   }
+    def properties(subject, recalc = false)
+      @properties ||= {}
+      @properties.delete(subject.to_s) if recalc
+      @properties[subject.to_s] ||= begin
+        hash = Hash.new
+        self.query(:subject => subject) do |statement|
+          pred = statement.predicate.to_s
+
+          hash[pred] ||= []
+          hash[pred] << statement.object
+        end
+        hash
+      end
+    end
+
+    # Get type(s) of subject, returns a list of symbols
+    def type_of(subject)
+      query(:subject => subject, :predicate => RDF.type).map {|st| st.object}
+    end
+  end
+end

data/lib/rdf/n3/patches/literal_hacks.rb

@@ -0,0 +1,23 @@
+module RDF
+  class Literal
+    # Support for XML Literals
+    # Is this an XMLLiteral?
+    def xmlliteral?
+      datatype == RDF['XMLLiteral']
+    end
+    
+    def anonymous?; false; end unless respond_to?(:anonymous?)
+    
+    ##
+    # Returns a string representation of this literal.
+    #
+    # @return [String]
+    def to_s
+      quoted = value # FIXME
+      output = "\"#{quoted.to_s.rdf_escape}\""
+      output << "@#{language}" if has_language? && !has_datatype?
+      output << "^^<#{datatype}>" if has_datatype?
+      output
+    end
+  end
+end

data/lib/rdf/n3/patches/literal_normalization.rb

@@ -0,0 +1,120 @@
+autoload :Date, 'date'
+autoload :DateTime, 'date'
+autoload :Time, 'time'
+
+module RDF
+  class Literal
+    ##
+    # Re-define initialize/new to call _normalize_ on value.
+    # @param  [Object]
+    # @option options [Symbol] :language (nil)
+    # @option options [URI]    :datatype (nil)
+    # @option options[Hash]    :namespaces ({})
+    def initialize_with_normalization(value, options = {})
+      initialize_without_normalization(value, options)
+      normalize(options)
+    end
+    
+    alias_method :initialize_without_normalization, :initialize
+    alias_method :initialize, :initialize_with_normalization
+
+    def valid?
+      case datatype
+      when XSD.boolean   then %w(1 true 0 false).include?(value.to_s.downcase)
+      when XSD.decimal   then !!value.to_s.match(/^[\+\-]?\d+(\.\d*)?$/)
+      when XSD.double    then !!value.to_s.match(/^[\+\-]?\d+(\.\d*([eE][\+\-]?\d+)?)?$/)
+      when XSD.integer   then !!value.to_s.match(/^[\+\-]?\d+$/)
+      else                    true
+      end
+    end
+
+    protected
+    
+    # Normalize literal value
+    #
+    # Options is a hash passed to initialize
+    def normalize(options = {})
+      return unless valid?  # Only normalize valid value
+
+      @value = case datatype
+      when XSD.boolean    then %(1 true).include?(@value.to_s.downcase) ? "true" : "false"
+      when XSD.integer    then @value.to_i.to_s
+      when XSD.decimal    then normalize_decimal(@value, options)
+      when XSD.double     then normalize_double(@value, options)
+      when XSD.time       then @value.is_a?(Time) ? @value.strftime("%H:%M:%S%Z").sub(/\+00:00|UTC/, "Z") : @value.to_s
+      when XSD.dateTime   then @value.is_a?(DateTime) ? @value.strftime("%Y-%m-%dT%H:%M:%S%Z").sub(/\+00:00|UTC/, "Z") : @value.to_s
+      when XSD.date       then @value.is_a?(Date) ? @value.strftime("%Y-%m-%d%Z").sub(/\+00:00|UTC/, "Z") : @value.to_s
+      when RDF.XMLLiteral then normalize_xmlliteral(@value, options)
+      else                    @value.to_s
+      end
+    end
+    
+    def normalize_decimal(contents, options)
+      # Can't use simple %f transformation do to special requirements from N3 tests in representation
+      i, f = contents.to_s.split(".")
+      f = f.to_s[0,16]  # Truncate after 15 decimal places
+      i.sub!(/^\+?0+(\d)$/, '\1')
+      f.sub!(/0*$/, '')
+      f = "0" if f.empty?
+      "#{i}.#{f}"
+    end
+    
+    def normalize_double(contents, options)
+      i, f, e = ("%.16E" % contents.to_f).split(/[\.E]/)
+      f.sub!(/0*$/, '')
+      f = "0" if f.empty?
+      e.sub!(/^\+?0+(\d)$/, '\1')
+      "#{i}.#{f}E#{e}"
+    end
+    
+    # Normalize an XML Literal, by adding necessary namespaces.
+    # This should be done as part of initialize
+    #
+    # namespaces is a hash of prefix => URIs
+    def normalize_xmlliteral(contents, options = {})
+      options[:namespaces] ||= {}
+
+      begin
+        # Only normalize if Nokogiri is included
+        require 'nokogiri' unless defined?(Nokogiri)
+      rescue LoadError => e
+        contents.to_s   # No normalization
+      end
+      
+      if contents.is_a?(String)
+        ns_hash = {}
+        options[:namespaces].each_pair do |prefix, uri|
+          attr = prefix.to_s.empty? ? "xmlns" : "xmlns:#{prefix}"
+          ns_hash[attr] = uri.to_s
+        end
+        ns_strs = []
+        ns_hash.each_pair {|a, u| ns_strs << "#{a}=\"#{u}\""}
+
+        # Add inherited namespaces to created root element so that they're inherited to sub-elements
+        contents = Nokogiri::XML::Document.parse("<foo #{ns_strs.join(" ")}>#{contents}</foo>").root.children
+      end
+
+      # Add already mapped namespaces and language
+      contents.map do |c|
+        if c.is_a?(Nokogiri::XML::Element)
+          c = Nokogiri::XML.parse(c.dup.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)).root
+          # Gather namespaces from self and decendant nodes
+          c.traverse do |n|
+            ns = n.namespace
+            next unless ns
+            prefix = ns.prefix ? "xmlns:#{ns.prefix}" : "xmlns"
+            c[prefix] = ns.href.to_s unless c.namespaces[prefix]
+          end
+          
+          # Add lanuage
+          if options[:language] && c["lang"].to_s.empty?
+            c["xml:lang"] = options[:language]
+          end
+        end
+        c.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)
+      end.join("")
+    end
+  end
+  
+  class NormalizationError < IOError; end
+end