rdf-n3 0.0.3 → 0.2.1

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

@@ -1,131 +0,0 @@
-# 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)
-    else
-      string.gsub!(ESCAPE_RE) { |c|
-                      s = Iconv.new('utf-16be', 'utf-8').iconv(c).unpack('H*').first.upcase
-                      "\\u" + s
-                    }
-    end
-    string
-  end
-  
-  # 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, 
-  })
-
-  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 RDF::ReaderError, "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
-    string.force_encoding(Encoding::UTF_8) if defined?(::Encoding)
-    string
-  rescue Iconv::Failure => e
-    raise RDF::ReaderError, "Caught #{e.class}: #{e}"
-  end
-end unless String.method_defined?(:rdf_escape)

data/spec/turtle_serializer_spec.rb

@@ -1,226 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-include RdfContext
-
-describe "Turtle Serializer" do
-  describe "simple tests" do
-    it "should use full URIs without base" do
-      input = %(<http://a/b> <http://a/c> <http://a/d> .)
-      serialize(input, nil, %r(^<http://a/b> <http://a/c> <http://a/d> \.$))
-    end
-
-    it "should use relative URIs with base" do
-      input = %(<http://a/b> <http://a/c> <http://a/d> .)
-      serialize(input, "http://a/",
-        %r(^@base <http://a/> \.$),
-        %r(^<b> <c> <d> \.$)
-      )
-    end
-
-    it "should use qname URIs with prefix" do
-      input = %(@prefix a: <http://a/> . <http://a/b> <http://a/c> <http://a/d> .)
-      serialize(input, nil,
-        %r(^@prefix a: <http://a/> \.$),
-        %r(^a:b a:c a:d \.$)
-      )
-    end
-
-    it "should use qname URIs with empty prefix" do
-      input = %(@prefix : <http://a/> . <http://a/b> <http://a/c> <http://a/d> .)
-      serialize(input, nil,
-        %r(^@prefix : <http://a/> \.$),
-        %r(^:b :c :d \.$)
-      )
-    end
-    
-    it "should order properties" do
-      input = %(
-        @prefix : <http://a/> .
-        @prefix dc: <http://purl.org/dc/elements/1.1/> .
-        @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
-        :b :c :d .
-        :b dc:title "title" .
-        :b a :class .
-        :b rdfs:label "label" .
-      )
-      serialize(input, nil,
-        %r(^:b a :class;$),
-        %r(^\s+rdfs:label "label"),
-        %r(^\s+dc:title \"title\"),
-        %r(^\s+:c :d)
-      )
-    end
-    
-    it "should generate object list" do
-      input = %(@prefix : <http://a/> . :b :c :d, :e .)
-      serialize(input, nil,
-        %r(^@prefix : <http://a/> \.$),
-        %r(^:b :c :d,$),
-        %r(^\s+:e \.$)
-      )
-    end
-    
-    it "should generate property list" do
-      input = %(@prefix : <http://a/> . :b :c :d; :e :f .)
-      serialize(input, nil,
-        %r(^@prefix : <http://a/> \.$),
-        %r(^:b :c :d;$),
-        %r(^\s+:e :f \.$)
-      )
-    end
-  end
-  
-  describe "anons" do
-    it "should generate bare anon" do
-      input = %(@prefix : <http://a/> . [:a :b] .)
-      serialize(input, nil,
-        %r(^\s*\[ :a :b\] \.$)
-      )
-    end
-    
-    it "should generate anon as subject" do
-      input = %(@prefix : <http://a/> . [:a :b] :c :d .)
-      serialize(input, nil,
-        %r(^\s*\[ :a :b;$),
-        %r(^\s+:c :d\] \.$)
-      )
-    end
-    
-    it "should generate anon as object" do
-      input = %(@prefix : <http://a/> . :a :b [:c :d] .)
-      serialize(input, nil,
-        %r(^\s*\:a :b \[ :c :d\] \.$)
-      )
-    end
-  end
-  
-  describe "lists" do
-    it "should generate bare list" do
-      input = %(@prefix : <http://a/> . (:a :b) .)
-      serialize(input, nil,
-        %r(^\(:a :b\) \.$)
-      )
-    end
-
-    it "should generate literal list" do
-      input = %(@prefix : <http://a/> . :a :b ( "apple" "banana" ) .)
-      serialize(input, nil,
-        %r(^:a :b \("apple" "banana"\) \.$)
-      )
-    end
-    
-    it "should generate empty list" do
-      input = %(@prefix : <http://a/> . :a :b () .)
-      serialize(input, nil,
-        %r(^:a :b \(\) \.$)
-      )
-    end
-    
-    it "should generate empty list(2)" do
-      input = %(@prefix : <http://a/> . :emptyList = () .)
-      serialize(input, nil,
-        %r(^:emptyList (<.*sameAs>|owl:sameAs) \(\) \.$)
-      )
-    end
-    
-    it "should generate empty list as subject" do
-      input = %(@prefix : <http://a/> . () :a :b .)
-      serialize(input, nil,
-        %r(^\(\) :a :b \.$)
-      )
-    end
-    
-    it "should generate list as subject" do
-      input = %(@prefix : <http://a/> . (:a) :b :c .)
-      serialize(input, nil,
-        %r(^\(:a\) :b :c \.$)
-      )
-    end
-
-    it "should generate list of empties" do
-      input = %(@prefix : <http://a/> . :listOf2Empties = (() ()) .)
-      serialize(input, nil,
-        %r(^:listOf2Empties (<.*sameAs>|owl:sameAs) \(\(\) \(\)\) \.$)
-      )
-    end
-    
-    it "should generate list anon" do
-      input = %(@prefix : <http://a/> . :twoAnons = ([a :mother] [a :father]) .)
-      serialize(input, nil,
-        %r(^:twoAnons (<.*sameAs>|owl:sameAs) \(\[\s*a :mother\] \[\s*a :father\]\) \.$)
-      )
-    end
-    
-    it "should generate owl:unionOf list" do
-      input = %(
-        @prefix : <http://a/> .
-        @prefix owl: <http://www.w3.org/2002/07/owl#> .
-        @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
-        @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
-        :a rdfs:domain [
-          a owl:Class;
-          owl:unionOf [
-            a owl:Class;
-            rdf:first :b;
-            rdf:rest [
-              a owl:Class;
-              rdf:first :c;
-              rdf:rest rdf:nil
-            ]
-          ]
-        ] .
-      )
-      serialize(input, nil,
-        %r(:a rdfs:domain \[\s*a owl:Class;\s+owl:unionOf\s+\(:b\s+:c\)\]\s*\.$)m
-      )
-    end
-  end
-  
-  # W3C Turtle Test suite from http://www.w3.org/2000/10/swap/test/regression.n3
-  describe "w3c turtle tests" do
-    require 'rdf_helper'
-
-    def self.positive_tests
-      RdfHelper::TestCase.test_cases(TURTLE_TEST, TURTLE_DIR) rescue []
-    end
-
-    positive_tests.each do |t|
-      #puts t.inspect
-      #next unless t.name == "test-04"
-      
-      specify "#{t.name}: " + (t.description || "#{t.inputDocument}") do
-        # Skip tests for very long files, too long
-        if %w(test-14 test-15 test-16 rdfq-results).include?(t.name)
-          pending("Skip very long input file")
-        elsif !defined?(::Encoding) && %w(test-18).include?(t.name)
-          pending("Not supported in Ruby 1.8")
-        elsif %w(test-29).include?(t.name)
-          pending("Silly test")
-        else
-          begin
-            t.run_test do |rdf_string, parser|
-              parser.parse(rdf_string, t.about.uri.to_s, :strict => true, :debug => [])
-              parser.graph.serialize(:format => :ttl, :base => t.about.uri.to_s)
-              t.compare = :none
-            end
-          #rescue #Spec::Expectations::ExpectationNotMetError => e
-          #  pending() {  raise }
-          end
-        end
-      end
-    end
-  end
-  
-  # Serialize ntstr to a string and compare against regexps
-  def serialize(ntstr, base = nil, *regexps)
-    g = Graph.new
-    g.parse(ntstr, base)
-    result = g.serialize(:format => :ttl, :base => base)
-    puts result if $verbose
-    
-    regexps.each do |re|
-      result.should =~ re
-    end
-    
-    result
-  end
-end