rdf-n3 0.2.2 → 0.2.3

data/script/parse

@@ -5,7 +5,7 @@ require 'rdf/n3'
 require 'getoptlong'
 
 def parse(input, base)
-  puts RDF::Writer.for($format.to_sym).buffer { |writer|
+  puts RDF::Writer.for($format.to_sym).buffer(:base_uri => base) { |writer|
     RDF::N3::Reader.new(input, :base_uri => base, :strict => true).each do |statement|
       writer << statement
     end
@@ -32,7 +32,7 @@ opts.each do |opt, arg|
   case opt
   when '--verbose' then $verbose = true
   when '--quiet' then $quiet = true
-  when '--debug' then $DEBUG = true
+  when '--debug' then ::RDF::N3::debug = true
   when '--execute' then input = arg
   when '--format' then $format = arg
   when '--uri' then base_uri = arg

data/script/tc

@@ -30,7 +30,7 @@ opts.each do |opt, arg|
   case opt
   when '--verbose' then $verbose = true
   when '--quiet' then $quiet = true
-  when '--debug' then $DEBUG = true
+  when '--debug' then ::RDF::N3::debug = true
   when '--format' then $format = arg
   when '--suite' then suite = arg
   when '--strict' then $strict = true

data/spec/n3reader_spec.rb

@@ -134,8 +134,23 @@ describe "RDF::N3::Reader" do
         "tab:\t" => ':a :b  "tab:\t" .',
         "é" => ':a :b  "\u00E9" .',
         "€" => ':a :b  "\u20AC" .',
+        "resumé" => ':a :resume  "resum\u00E9" .',
       }.each_pair do |contents, triple|
-        specify "test #{contents}" do
+        specify "test #{triple}" do
+          graph = parse(triple, :base_uri => "http://a/b")
+          statement = graph.statements.first
+          graph.size.should == 1
+          statement.object.value.should == contents
+        end
+      end
+      
+      {
+        'Dürst' => ':a :b "Dürst" .',
+        "é" => ':a :b  "é" .',
+        "€" => ':a :b  "€" .',
+        "resumé" => ':a :resume  "resumé" .',
+      }.each_pair do |contents, triple|
+        specify "test #{triple}" do
           graph = parse(triple, :base_uri => "http://a/b")
           statement = graph.statements.first
           graph.size.should == 1
@@ -246,6 +261,12 @@ describe "RDF::N3::Reader" do
       end
     end
 
+    it "should allow mixed-case language" do
+      n3doc = %(:x2 :p "xyz"@EN .)
+      statement = parse(n3doc).statements.first
+      statement.object.to_ntriples.should == %("xyz"@en)
+    end
+
     it "should create typed literals" do
       n3doc = "<http://example.org/joe> <http://xmlns.com/foaf/0.1/name> \"Joe\"^^<http://www.w3.org/2001/XMLSchema#string> ."
       statement = parse(n3doc).statements.first
@@ -271,6 +292,25 @@ describe "RDF::N3::Reader" do
         end
       end
 
+      {
+        %(<#Dürst> :knows :jane.) => '<http://a/b#D\u00FCrst> <http://a/b#knows> <http://a/b#jane> .',
+        %(:Dürst :knows :jane.) => '<http://a/b#D\u00FCrst> <http://a/b#knows> <http://a/b#jane> .',
+        %(:bob :resumé "Bob's non-normalized resumé".) => '<http://a/b#bob> <http://a/b#resumé> "Bob\'s non-normalized resumé" .',
+        %(:alice :resumé "Alice's normalized resumé".) => '<http://a/b#alice> <http://a/b#resumé> "Alice\'s normalized resumé" .',
+        }.each_pair do |n3, nt|
+          it "for '#{n3}'" do
+            begin
+              parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
+            rescue
+              if defined?(::Encoding)
+                raise
+              else
+                pending("Unicode URIs not supported in Ruby 1.8") {  raise } 
+              end
+            end
+          end
+        end
+
       {
         %(<#Dürst>       a  "URI straight in UTF8".) => %(<http://a/b#D\\u00FCrst> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> "URI straight in UTF8" .),
         #%(:a :related :ひらがな .) => %(<http://a/b#a> <http://a/b#related> <http://a/b#\\u3072\\u3089\\u304C\\u306A> .),
@@ -442,9 +482,13 @@ describe "RDF::N3::Reader" do
         parse(n3, :base_uri => "http://a/b").should be_equivalent_graph(nt, :about => "http://a/b", :trace => @debug)
       end
       
-      it "should do something for @forAll"
+      it "should do something for @forAll" do
+        pending
+      end
 
-      it "should do something for @forSome"
+      it "should do something for @forSome" do
+        pending
+      end
     end
     
     describe "namespaces" do
@@ -784,9 +828,13 @@ describe "RDF::N3::Reader" do
     end
     
     describe "formulae" do
-      it "should require that graph be formula_aware when encountering a formlua"
+      it "should require that graph be formula_aware when encountering a formlua" do
+        pending
+      end
       
-      it "should separate triples between specified and quoted graphs"
+      it "should separate triples between specified and quoted graphs" do
+        pending
+      end
     end
     
     describe "object lists" do

data/spec/rdf_helper.rb

@@ -52,24 +52,24 @@ module RdfHelper
         pred = statement.predicate.to_s.split(/[\#\/]/).last
         obj  = statement.object.is_a?(RDF::Literal) ? statement.object.value : statement.object.to_s
 
-        puts "#{pred}: #{obj}" if $DEBUG
+        puts "#{pred}: #{obj}" if ::RDF::N3::debug?
         if statement.predicate == RDF.type
           self.rdf_type = obj.to_s.split(/[\#\/]/).last
           #puts statement.subject.to_s
         elsif pred =~ /Document\Z/i
-          puts "sub #{uri_prefix} in #{obj} for #{test_dir}" if $DEBUG
+          puts "sub #{uri_prefix} in #{obj} for #{test_dir}" if ::RDF::N3::debug?
           about = obj.dup
           obj.sub!(uri_prefix, test_dir)
-          puts " => #{obj}" if $DEBUG
+          puts " => #{obj}" if ::RDF::N3::debug?
           self.send("#{pred}=", obj)
           if pred == "inputDocument"
             self.about ||= about
             self.name ||= statement.subject.to_s.split(/[\#\/]/).last
           end
         elsif pred == "referenceOutput"
-          puts "referenceOutput: #{obj}" if $DEBUG
+          puts "referenceOutput: #{obj}" if ::RDF::N3::debug?
           outputDocument = obj.sub(uri_prefix, test_dir)
-          puts "referenceOutput: " + self.send(pred) if $DEBUG
+          puts "referenceOutput: " + self.send(pred) if ::RDF::N3::debug?
         elsif self.respond_to?("#{pred}=")
           self.send("#{pred}=", obj)
         end
@@ -130,7 +130,7 @@ module RdfHelper
         @parser.graph.should be_equivalent_graph(self.output, self)
       else
         output_graph = RDF::Graph.load(self.outputDocument, :format => detect_format(self.outputDocument))
-        puts "result: #{CGI.escapeHTML(graph.to_ntriples)}" if $DEBUG
+        puts "result: #{CGI.escapeHTML(graph.to_ntriples)}" if ::RDF::N3::debug?
         graph.should Matchers::be_equivalent_graph(output_graph, self)
       end
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rdf-n3
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 2
-  - 2
-  version: 0.2.2
+  - 3
+  version: 0.2.3
 platform: ruby
 authors: 
 - Gregg Kellogg
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-11 00:00:00 -07:00
+date: 2010-11-10 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -56,12 +56,14 @@ dependencies:
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - "="
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 27
         segments: 
+        - 1
+        - 3
         - 0
-        version: "0"
+        version: 1.3.0
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -147,13 +149,13 @@ files:
 - lib/rdf/n3/format.rb
 - lib/rdf/n3/patches/array_hacks.rb
 - lib/rdf/n3/patches/graph_properties.rb
-- lib/rdf/n3/patches/literal_normalization.rb
 - lib/rdf/n3/patches/qname_hacks.rb
 - lib/rdf/n3/patches/seq.rb
-- lib/rdf/n3/patches/uri_hacks.rb
 - lib/rdf/n3/reader.rb
 - lib/rdf/n3/reader/n3_grammar.rb
 - lib/rdf/n3/reader/n3_grammar.treetop
+- lib/rdf/n3/reader/n3_grammar_18.rb
+- lib/rdf/n3/reader/n3_grammar_18.treetop
 - lib/rdf/n3/version.rb
 - lib/rdf/n3/vocab.rb
 - lib/rdf/n3/writer.rb

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

@@ -1,158 +0,0 @@
-# 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
-  ##
-  # 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
-    ##
-    # @param  [Object] value
-    # @option options [String] :lexical (nil)
-    # @option options [Hash] :namespaces ({}) Use :__default__ or "" to declare default namespace
-    # @option options [Symbol] :language (nil)
-    # @option options [Symbol] :library (:nokogiri, :libxml, or :rexml)
-    def initialize(value, options = {})
-      options[:namespaces] ||= {}
-
-      @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
-
-    ##
-    # Converts the literal into its canonical lexical representation.
-    #
-    # @return [Literal]
-    # @see    http://www.w3.org/TR/xml-exc-c14n/
-    def canonicalize
-      # This is the opportunity to use exclusive canonicalization library
-      self
-    end
-
-    ##
-    # Returns the value as a string.
-    #
-    # @return [String]
-    def to_s
-      @string
-    end
-    
-    private
-    
-    def parse_value(value, options)
-      ns_hash = {}
-      options[:namespaces].each_pair do |prefix, uri|
-        prefix = prefix == :__default__ ? "" : prefix.to_s
-        attr = prefix.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 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
-    
-    # Nokogiri implementations
-    if defined?(::Nokogiri)
-      # A somewhat half-hearted attempt at C14N.
-      # Main problem is that it promotes all namespaces to top element, instead of demoting them
-      # to the required element, and does not properly order either namespaces or attributes.
-      #
-      # An open-issue in Nokogiri is to add support for C14N from the underlying libxml2 libraries.
-      def parse_value_nokogiri(value, ns_strs, language)
-        elements = if value.is_a?(Nokogiri::XML::NodeSet)
-          value
-        else
-          # Add inherited namespaces to created root element so that they're inherited to sub-elements
-          Nokogiri::XML::Document.parse("<foo #{ns_strs.join(" ")}>#{value.to_s}</foo>").root.children
-        end
-
-        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 language
-            if language && c["lang"].to_s.empty?
-              c["xml:lang"] = language.to_s
-            end
-          end
-          c
-        end
-      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)
-      # This should use Document#canonicalize if as and when it is available in libxml-ruby
-      def parse_value_libxml(value, ns_strs, language)
-        # Fixme
-      end
-
-      def serialize_nodeset_libxml(object)
-        # Fixme
-      end
-    end   # LibXML
-    
-    # REXML
-    # This could make use of the XMLCanonicalizer gem (http://rubygems.org/gems/XMLCanonicalizer)
-    # But, it hasn't been touched since 2007 and relies on log4r.
-    def parse_value_rexml(value, ns_strs, language)
-      # Fixme
-    end
-
-    def serialize_nodeset_rexml(object)
-      # Fixme
-    end
-    
-  end # class XML
-end; end

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

@@ -1,29 +0,0 @@
-module RDF
-  class URI
-    ##
-    # Joins several URIs together.
-    #
-    # @param  [Array<String, URI, #to_str>] uris
-    # @return [URI]
-    #
-    # GK -- don't add a "/" at the end of URIs, due to rdfcore/xmlbase/test002.rdf
-    def join(*uris)
-      result = @uri
-      uris.each do |uri|
-#        result.path += '/' unless result.path.match(/[\#\/]$/) || uri.to_s[0..0] == "#"
-        result = result.join(uri)
-      end
-      self.class.new(result)
-    end
-    
-    # From http://www.w3.org/TR/2004/REC-rdf-concepts-20040210/#section-Graph-URIref
-    #
-    # A URI Reference within an RDF graph is a Unicode string that:
-    # * does not contain any control characters ( #x00 - #x1F, #x7F-#x9F)
-    # * and would produce a valid URI character sequence (per RFC2396 [URI], sections 2.1) representing an absolute URI with optional fragment identifier when subjected to the encoding described below.
-    #
-    # The encoding consists of:
-    # 1. encoding the Unicode string as UTF-8 [RFC-2279], giving a sequence of octet values.
-    # 2. %-escaping octets that do not correspond to permitted US-ASCII characters.
-  end
-end