rdf-n3 0.0.3 → 0.2.1

data/History.txt

@@ -1,3 +1,6 @@
+=== 0.2.1
+* Compatible with RDF.rb 0.2.1
+
 === 0.0.3
 * Replace require against rdf/rdfxml/patches/* with rdf/n3/patches/*
 

data/Rakefile

@@ -13,11 +13,11 @@ begin
     gemspec.email = "gregg@kellogg-assoc.com"
     gemspec.homepage = "http://github.com/gkellogg/rdf-rdfa"
     gemspec.authors = ["Gregg Kellogg"]
-    gemspec.add_dependency('rdf', '>= 0.2.0')
+    gemspec.add_dependency('rdf', '>= 0.2.1')
     gemspec.add_dependency('treetop',  '>= 1.4.0')
     gemspec.add_development_dependency('rspec')
-    gemspec.add_development_dependency('rdf-spec')
-    gemspec.add_development_dependency('rdf-rdfxml', '>= 0.2.0')
+    gemspec.add_development_dependency('rdf-spec', '>= 0.2.1')
+    gemspec.add_development_dependency('rdf-rdfxml', '>= 0.2.1')
     gemspec.add_development_dependency('rdf-isomorphic')
     gemspec.add_development_dependency('yard')
     gemspec.extra_rdoc_files     = %w(README.rdoc History.txt AUTHORS)

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.2.1

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

@@ -1,120 +1,147 @@
-autoload :Date, 'date'
-autoload :DateTime, 'date'
-autoload :Time, 'time'
+# Use Nokogiri or LibXML when available, and REXML otherwise:
+begin
+  require 'nokogiri'
+rescue LoadError => e
+  begin
+    require 'libxml'
+  rescue LoadError => e
+    :rexml
+  end
+end
 
-module RDF
-  class Literal
+module RDF; class Literal
+  ##
+  # An XML literal.
+  #
+  # @see   http://www.w3.org/TR/rdf-concepts/#section-XMLLiteral
+  # @see   http://www.w3.org/TR/rdfa-core/#s_xml_literals
+  # @since 0.2.1
+  class XML < Literal
     ##
-    # Re-define initialize/new to call _normalize_ on value.
-    # @param  [Object]
+    # @param  [Object] value
+    # @option options [String] :lexical (nil)
+    # @option options [Hash] :namespaces (nil)
+    # @option options [Hash] :namespaces ({})
     # @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
+    # @option options [Symbol] :library (:nokogiri, :libxml, or :rexml)
+    def initialize(value, options = {})
+      options[:namespaces] ||= {}
 
-    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
+      @library = case options[:library]
+        when nil
+          case
+          when defined?(::Nokogiri) then :nokogiri
+          when defined?(::LibXML)   then :libxml
+          else                           :rexml
+          end
+        when :nokogiri, :libxml, :rexml
+          options[:library]
+        else
+          raise ArgumentError.new("expected :rexml, :libxml or :nokogiri, but got #{options[:library].inspect}")
       end
+
+      @datatype = options[:datatype] || DATATYPE
+      @string   = options[:lexical] if options.has_key?(:lexical)
+      @object   = parse_value(value, options)
+      @string   = serialize_nodeset(@object)
     end
 
-    protected
-    
-    # Normalize literal value
+    ##
+    # Converts the literal into its canonical lexical representation.
     #
-    # Options is a hash passed to initialize
-    def normalize(options = {})
-      return unless valid?  # Only normalize valid value
+    # @return [Literal]
+    # @see    http://www.w3.org/TR/xml-exc-c14n/
+    def canonicalize
+      # This is the opportunity to use exclusive canonicalization library
+      self
+    end
 
-      @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
+    ##
+    # Returns the value as a string.
+    #
+    # @return [String]
+    def to_s
+      @string
     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}"
+    private
+    
+    def parse_value(value, options)
+      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}\""}
+
+      case @library
+      when :nokogiri  then parse_value_nokogiri(value, ns_strs, options[:language])
+      when :libxml    then parse_value_libxml(value, ns_strs, options[:language])
+      when :rexml     then parse_value_rexml(value, ns_strs, options[:language])
+      else                 value.to_s
+      end
     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}"
+    def serialize_nodeset(object)
+      case @library
+      when :nokogiri  then serialize_nodeset_nokogiri(object)
+      when :libxml    then serialize_nodeset_libxml(object)
+      when :rexml     then serialize_nodeset_rexml(object)
+      else                 object
+      end
     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] ||= {}
+    # Nokogiri implementations
+    if defined?(::Nokogiri)
+      def parse_value_nokogiri(value, ns_strs, language)
+        return value if value.is_a?(Nokogiri::XML::NodeSet)
+        # Add inherited namespaces to created root element so that they're inherited to sub-elements
+        elements = Nokogiri::XML::Document.parse("<foo #{ns_strs.join(" ")}>#{value.to_s}</foo>").root.children
 
-      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
+        elements.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 language && c["lang"].to_s.empty?
+              c["xml:lang"] = language
+            end
+          end
+          c
         end
-        ns_strs = []
-        ns_hash.each_pair {|a, u| ns_strs << "#{a}=\"#{u}\""}
+      end
+    
+      def serialize_nodeset_nokogiri(object)
+        object.map {|c| c.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)}.join("")
+      end
+    end   # Nokogiri
+    
+    if defined?(::LibXML)
+      def parse_value_libxml(value, ns_strs, language)
+        # Fixme
+      end
 
-        # 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
+      def serialize_nodeset_libxml(object)
+        # Fixme
       end
+    end   # LibXML
+    
+    # REXML
+    def parse_value_rexml(value, ns_strs, language)
+      # Fixme
+    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("")
+    def serialize_nodeset_rexml(object)
+      # Fixme
     end
-  end
-  
-  class NormalizationError < IOError; end
-end
+    
+  end # class XML
+end; end

data/lib/rdf/n3/reader.rb

@@ -344,9 +344,9 @@ module RDF::N3
     def process_uri(uri, normalize = true)
       uri = uri.text_value if uri.respond_to?(:text_value)
       if uri.match(/^\#/)
-        uri(@uri, uri.rdf_escape, false) # This is probably bogus, but allows tests to pass
+        uri(@uri, RDF::NTriples::Writer.escape(uri), false) # This is probably bogus, but allows tests to pass
       else
-        uri = uri.rdf_escape unless normalize # Addressable does it's own escaping when normalizing
+        uri = RDF::NTriples::Writer.escape(uri) unless normalize # Addressable does it's own escaping when normalizing
         uri(@uri, uri, normalize)
       end
     end
@@ -392,7 +392,7 @@ module RDF::N3
 
       # Evaluate text_value to remove redundant escapes
       #puts string.elements[1].text_value.dump
-      lit = RDF::Literal.new(string.elements[1].text_value.rdf_unescape, :language => language, :datatype => encoding)
+      lit = RDF::Literal.new(RDF::NTriples::Reader.unescape(string.elements[1].text_value), :language => language, :datatype => encoding)
       raise RDF::ReaderError, %(Typed literal has an invalid lexical value: #{encoding.to_s} "#{lit.value}") if @strict && !lit.valid?
       lit
     end
@@ -400,7 +400,7 @@ module RDF::N3
     def process_numeric_literal(object)
       add_debug(*object.info("process_numeric_literal"))
 
-      RDF::Literal.new(object.text_value.rdf_unescape, :datatype => RDF::XSD[object.numericliteral])
+      RDF::Literal.new(RDF::NTriples::Reader.unescape(object.text_value), :datatype => RDF::XSD[object.numericliteral])
     end
     
     def build_uri(expression)
@@ -408,6 +408,7 @@ module RDF::N3
       localname = expression.localname.text_value if expression.respond_to?(:localname)
       localname ||= (expression.respond_to?(:text_value) ? expression.text_value : expression).to_s.sub(/^:/, "")
       localname = nil if localname.empty? # In N3/Turtle "_:" is not named
+      escaped_localname = RDF::NTriples::Writer.escape(localname.to_s)
 
       if expression.respond_to?(:info)
         add_debug(*expression.info("build_uri(#{prefix.inspect}, #{localname.inspect})"))
@@ -416,23 +417,23 @@ module RDF::N3
       end
 
       uri = if @uri_mappings[prefix]
-        add_debug(*expression.info("build_uri: (ns): #{@uri_mappings[prefix]}, #{localname.to_s.rdf_escape}")) if expression.respond_to?(:info)
-        ns(prefix, localname.to_s.rdf_escape)
+        add_debug(*expression.info("build_uri: (ns): #{@uri_mappings[prefix]}, #{escaped_localname}")) if expression.respond_to?(:info)
+        ns(prefix, RDF::NTriples::Writer.escape(localname.to_s))
       elsif prefix == '_'
         add_debug(*expression.info("build_uri: (bnode)")) if expression.respond_to?(:info)
         bnode(localname)
       elsif prefix == "rdf"
         add_debug(*expression.info("build_uri: (rdf)")) if expression.respond_to?(:info)
         # A special case
-        RDF::RDF[localname.to_s.rdf_escape]
+        RDF::RDF[escaped_localname]
       elsif prefix == "xsd"
         add_debug(*expression.info("build_uri: (xsd)")) if expression.respond_to?(:info)
         # A special case
-        RDF::XSD[localname.to_s.rdf_escape]
+        RDF::XSD[escaped_localname]
       else
         add_debug(*expression.info("build_uri: (default_ns)")) if expression.respond_to?(:info)
         @default_ns ||= uri("#{@uri}#", nil)
-        ns(nil, localname.to_s.rdf_escape)
+        ns(nil, escaped_localname)
       end
       add_debug(*expression.info("build_uri: #{uri.inspect}")) if expression.respond_to?(:info)
       uri

data/lib/rdf/n3/version.rb

@@ -1,7 +1,7 @@
 module RDF::N3::VERSION
   MAJOR = 0
-  MINOR = 0
-  TINY  = 3
+  MINOR = 2
+  TINY  = 1
   EXTRA = nil
 
   STRING = [MAJOR, MINOR, TINY].join('.')

data/lib/rdf/n3/writer.rb

@@ -374,7 +374,7 @@ module RDF::N3
     end
     
     def label(node)
-      get_qname(node) || (node.uri? ? "<#{node}>" : node.to_s)
+      get_qname(node) || node.to_ntriples
     end
 
     def add_namespace(prefix, ns)

data/lib/rdf/n3.rb

@@ -23,11 +23,9 @@ module RDF
     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'

data/rdf-n3.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rdf-n3}
-  s.version = "0.0.3"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gregg Kellogg"]
-  s.date = %q{2010-06-25}
+  s.date = %q{2010-06-28}
   s.description = %q{    RDF::N3 is an Notation-3 (n3-rdf) parser for Ruby using the RDF.rb library suite.
 }
   s.email = %q{gregg@kellogg-assoc.com}
@@ -31,10 +31,8 @@ Gem::Specification.new do |s|
      "lib/rdf/n3/format.rb",
      "lib/rdf/n3/patches/array_hacks.rb",
      "lib/rdf/n3/patches/graph_properties.rb",
-     "lib/rdf/n3/patches/literal_hacks.rb",
      "lib/rdf/n3/patches/literal_normalization.rb",
      "lib/rdf/n3/patches/qname_hacks.rb",
-     "lib/rdf/n3/patches/rdf_escape.rb",
      "lib/rdf/n3/patches/seq.rb",
      "lib/rdf/n3/patches/uri_hacks.rb",
      "lib/rdf/n3/reader.rb",
@@ -604,14 +602,13 @@ Gem::Specification.new do |s|
      "spec/turtle/test-29.ttl",
      "spec/turtle/test-30.out",
      "spec/turtle/test-30.ttl",
-     "spec/turtle_serializer_spec.rb",
      "spec/turtle_spec.rb",
      "spec/writer_spec.rb"
   ]
   s.homepage = %q{http://github.com/gkellogg/rdf-rdfa}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{Notation-3 (n3-rdf) and Turtle reader/writer for RDF.rb.}
   s.test_files = [
     "spec/cwm_spec.rb",
@@ -622,7 +619,6 @@ Gem::Specification.new do |s|
      "spec/rdf_helper.rb",
      "spec/spec_helper.rb",
      "spec/swap_spec.rb",
-     "spec/turtle_serializer_spec.rb",
      "spec/turtle_spec.rb",
      "spec/writer_spec.rb"
   ]
@@ -631,29 +627,29 @@ Gem::Specification.new do |s|
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<rdf>, [">= 0.2.0"])
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rdf>, [">= 0.2.1"])
       s.add_runtime_dependency(%q<treetop>, [">= 1.4.0"])
       s.add_development_dependency(%q<rspec>, [">= 0"])
-      s.add_development_dependency(%q<rdf-spec>, [">= 0"])
-      s.add_development_dependency(%q<rdf-rdfxml>, [">= 0.2.0"])
+      s.add_development_dependency(%q<rdf-spec>, [">= 0.2.1"])
+      s.add_development_dependency(%q<rdf-rdfxml>, [">= 0.2.1"])
       s.add_development_dependency(%q<rdf-isomorphic>, [">= 0"])
       s.add_development_dependency(%q<yard>, [">= 0"])
     else
-      s.add_dependency(%q<rdf>, [">= 0.2.0"])
+      s.add_dependency(%q<rdf>, [">= 0.2.1"])
       s.add_dependency(%q<treetop>, [">= 1.4.0"])
       s.add_dependency(%q<rspec>, [">= 0"])
-      s.add_dependency(%q<rdf-spec>, [">= 0"])
-      s.add_dependency(%q<rdf-rdfxml>, [">= 0.2.0"])
+      s.add_dependency(%q<rdf-spec>, [">= 0.2.1"])
+      s.add_dependency(%q<rdf-rdfxml>, [">= 0.2.1"])
       s.add_dependency(%q<rdf-isomorphic>, [">= 0"])
       s.add_dependency(%q<yard>, [">= 0"])
     end
   else
-    s.add_dependency(%q<rdf>, [">= 0.2.0"])
+    s.add_dependency(%q<rdf>, [">= 0.2.1"])
     s.add_dependency(%q<treetop>, [">= 1.4.0"])
     s.add_dependency(%q<rspec>, [">= 0"])
-    s.add_dependency(%q<rdf-spec>, [">= 0"])
-    s.add_dependency(%q<rdf-rdfxml>, [">= 0.2.0"])
+    s.add_dependency(%q<rdf-spec>, [">= 0.2.1"])
+    s.add_dependency(%q<rdf-rdfxml>, [">= 0.2.1"])
     s.add_dependency(%q<rdf-isomorphic>, [">= 0"])
     s.add_dependency(%q<yard>, [">= 0"])
   end