rdf-n3 0.2.3.2 → 0.3.0

data/lib/rdf/n3/reader/n3_grammar_18.treetop

@@ -1,227 +0,0 @@
-#encoding: utf-8
-grammar N3Grammer
-  # Entry point to grammar
-  rule document
-    statements
-  end
-
-  rule barename
-    barename_start barename_tail*
-  end
-
-  rule barename_start
-    [A-Z_a-z\p{Alpha}]
-  end
-  
-  rule barename_tail
-    barename_start / [-0-9\\]
-  end
-  
-  rule hexdigit
-    [0-9a-fA-F]
-  end
-  
-  rule integer
-     [+-]? [0-9]+
-  end
-  
-  rule barename_csl
-    space+ barename barename_csl_tail
-    / ""
-  end
-
-  rule barename_csl_tail
-    space* "," space* barename space* barename_csl_tail
-    / ""
-  end
-
-  rule boolean
-    "@"* ("true" / "false")
-  end
-  
-  rule comment
-    '#' (![\n\r] .)*
-  end
-
-  rule declaration
-    "@"? 'keywords' barename_csl {
-      def declaration; true; end
-      def keywords; true;end
-    }
-    / "@"? 'base' space+ explicituri:explicituri {
-      def declaration; true; end
-      def base; true; end
-    }
-    / "@"? 'prefix' space+ nprefix:nprefix? ':' space* explicituri:explicituri {
-      def declaration; true; end
-    }
-  end
-  
-  rule decimal
-    integer '.' [0-9]+
-  end
-  
-  rule double
-    decimal [eE] integer
-  end
-  
-  rule existential
-    "@"? "forSome" space+ symbol_csl
-  end
-  
-  rule explicituri
-   "<" uri:URI_Reference ">"
-  end
-  
-  rule expression
-    pathitem space* '.' expression  
-    / pathitem space* "!" space* expression
-    / pathitem space* "^" space* expression { def reverse; true; end }
-    / pathitem
-  end
-
-  rule language
-    [a-zA-Z]+ ( "-" [a-zA-Z0-9]+ )*
-  end
-
-  rule literal
-    (string_single / string_multi) ("^^" symbol / "@" language )?
-  end
-  
-  rule localname
-    barename
-  end
-  
-  rule nprefix
-    barename
-  end
-
-  rule numericliteral
-    double { def numericliteral; "double"; end}
-    / decimal { def numericliteral; "decimal"; end}
-    / integer { def numericliteral; "integer"; end}
-  end
-  
-  rule object
-    expression
-  end
-  
-  rule object_list
-    object space* "," space* object_list
-    / object
-  end
-
-  rule pathitem
-    boolean { def boolean; true; end }
-    / literal { def literal; true; end }
-    / numericliteral
-    #/ quickvariable
-    / symbol
-    / "[" space* "]" { def anonnode; true; end }
-    / "[" space* property_list space* "]" { def anonnode; true; end }
-    / "{" space* statements space* "}" { def anonnode; true; end }
-    / "(" space* path_list space* ")" { def anonnode; true; end }
-  end
-  
-  rule path_list
-    expression space* path_list
-    / ""
-  end
-  
-  rule prop
-    expression
-  end
-  
-  rule property_list
-    verb space* object_list space* ";"+ space* property_list
-    / verb space* object_list space* ";"*
-    / verb space* ";"* {def object_missing; true; end}
-    / ""
-  end
-
-  rule qname
-    nprefix ":" localname
-    / nprefix ':' { def text_value; ""; end }
-    / ':' localname*
-    / localname { def barename; true; end }
-  end
-  
-  rule simpleStatement
-    subject space+ property_list
-    / subject # For [] and a.b
-  end
-  
-  rule space
-    [ \t\n\r]+ / comment
-  end
-  
-  rule statement
-    declaration
-    / existential
-    / simpleStatement
-    / universal
-  end
-  
-  rule statements
-    (space / statement space* ('.' space*)? )*
-  end
-  
-  # " constant-value-with-escaping "
-  rule string_single
-    '""' !["] / '"' string_single_char+ '"'
-  end
-
-  rule string_single_char
-    !["\n\r] (
-      ("\\"
-        [\\\"bfnrt]
-      / ( "u" hexdigit hexdigit hexdigit hexdigit )
-      / ( "U" "00" hexdigit hexdigit hexdigit hexdigit hexdigit hexdigit)
-      )
-    / .)
-  end
-
-  # """ constant value with escaping including single or double occurrences of quotes and/or newlines """ 
-  rule string_multi
-    '"""' string_multi_single_char* '"""'
-  end
-
-  rule string_multi_single_char
-    "\\\""
-    / !('"""') .
-  end
-
-  rule subject
-    expression
-  end
-  
-  rule symbol
-    qname / explicituri
-  end
-  
-  rule symbol_csl
-    symbol space* "," space* symbol_csl
-    / symbol
-  end
-  
-  rule verb
-    "@"? "has" space+ prop                    # has xxx
-    / "@"? "is" space+ prop space+ "@"? "of" { # is xxx of
-      def invert; true; end
-    }
-    / "@"? "a" !":"                           # has rdf:type
-    / "=>"                                    # has log:implies
-    / "<=" { def invert; true; end }          # is log:implies of
-    / "="                                     # has owl:sameAs
-    / prop                                    # has xxx of -- shorthand
-  end
-  
-  rule universal
-    "@"? "forAll" space+ symbol_csl
-  end
-  
-  rule URI_Reference
-    [^{}<>]*
-  end
-  
-end

data/spec/literal_spec.rb

@@ -1,245 +0,0 @@
-# coding: utf-8
-$:.unshift "."
-require File.join(File.dirname(__FILE__), 'spec_helper')
-require 'nokogiri'
-
-describe RDF::Literal do
-  require 'nokogiri' rescue nil
-
-  before :each do 
-    @new = Proc.new { |*args| RDF::Literal.new(*args) }
-  end
-
-  describe "XML Literal" do
-    describe "with no namespace" do
-      subject { @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral) }
-      it "should return input" do subject.to_s.should == "foo <sup>bar</sup> baz!" end
-
-      it "should be equal if they have the same contents" do
-        should == @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral)
-      end
-    end
-
-    describe "with a namespace" do
-      subject {
-        @new.call("foo <dc:sup>bar</dc:sup> baz!", :datatype => RDF.XMLLiteral,
-                      :namespaces => {:dc => RDF::DC.to_s})
-      }
-
-      it "should add namespaces" do subject.to_s.should == "foo <dc:sup xmlns:dc=\"http://purl.org/dc/terms/\">bar</dc:sup> baz!" end
-
-        describe "as string prefix" do
-          subject {
-            @new.call("foo <dc:sup>bar</dc:sup> baz!", :datatype => RDF.XMLLiteral,
-                          :namespaces => {"dc" => RDF::DC.to_s})
-          }
-
-          it "should add namespaces" do subject.to_s.should == "foo <dc:sup xmlns:dc=\"http://purl.org/dc/terms/\">bar</dc:sup> baz!" end
-        end
-
-      describe "and language" do
-        subject {
-          @new.call("foo <dc:sup>bar</dc:sup> baz!", :datatype => RDF.XMLLiteral,
-                        :namespaces => {:dc => RDF::DC.to_s},
-                        :language => :fr)
-        }
-
-        it "should add namespaces and language" do subject.to_s.should == "foo <dc:sup xmlns:dc=\"http://purl.org/dc/terms/\" xml:lang=\"fr\">bar</dc:sup> baz!" end
-      end
-
-      describe "and node set" do
-        subject {
-          root = Nokogiri::XML.parse(%(<?xml version="1.0" encoding="UTF-8"?>
-          <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">
-          <html xmlns="http://www.w3.org/1999/xhtml"
-                xmlns:dc="http://purl.org/dc/terms/"
-                xmlns:ex="http://example.org/rdf/"
-                xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-                xmlns:svg="http://www.w3.org/2000/svg">
-            <head profile="http://www.w3.org/1999/xhtml/vocab http://www.w3.org/2005/10/profile">
-              <title>Test 0100</title>
-            </head>
-            <body>
-              <div about="http://www.example.org">
-                <h2 property="ex:example" datatype="rdf:XMLLiteral"><svg:svg/></h2>
-              </div>
-            </body>
-          </html>
-          ), nil, nil, Nokogiri::XML::ParseOptions::DEFAULT_XML).root
-          content = root.css("h2").children
-          @new.call(content, :datatype => RDF.XMLLiteral,
-                    :namespaces => {
-                      :svg => "http://www.w3.org/2000/svg",
-                      :dc => "http://purl.org/dc/terms/",
-                    })
-        }
-        it "should add namespace" do subject.to_s.should == "<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"></svg:svg>" end
-      end
-
-      describe "and language with an existing language embedded" do
-        subject {
-          @new.call("foo <dc:sup>bar</dc:sup><dc:sub xml:lang=\"en\">baz</dc:sub>",
-                        :datatype => RDF.XMLLiteral,
-                        :namespaces => {:dc => RDF::DC.to_s},
-                        :language => :fr)
-        }
-
-        it "should add namespaces and language" do subject.to_s.should == "foo <dc:sup xmlns:dc=\"http://purl.org/dc/terms/\" xml:lang=\"fr\">bar</dc:sup><dc:sub xmlns:dc=\"http://purl.org/dc/terms/\" xml:lang=\"en\">baz</dc:sub>" end
-      end
-    end
-
-    describe "with a default namespace" do
-      subject {
-        @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral,
-                      :namespaces => {:__default__ => RDF::DC.to_s})
-      }
-
-      it "should add namespace" do subject.to_s.should == "foo <sup xmlns=\"http://purl.org/dc/terms/\">bar</sup> baz!" end
-    end
-
-    describe "with a default namespace (as empty string)" do
-      subject {
-        @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral,
-                      :namespaces => {"" => RDF::DC.to_s})
-      }
-
-      it "should add namespace" do subject.to_s.should == "foo <sup xmlns=\"http://purl.org/dc/terms/\">bar</sup> baz!" end
-    end
-
-    context "rdfcore tests" do
-      context "rdfms-xml-literal-namespaces" do
-        it "should reproduce test001" do
-          l = @new.call("
-      <html:h1>
-        <b>John</b>
-      </html:h1>
-   ",
-                      :datatype => RDF.XMLLiteral,
-                      :namespaces => {
-                        "" => "http://www.w3.org/1999/xhtml",
-                        "rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
-                        "html" => "http://NoHTML.example.org",
-                        "my" => "http://my.example.org/",
-                      })
-
-          pending do
-            l.to_s.should == "\n      <html:h1 xmlns:html=\"http://NoHTML.example.org\">\n        <b xmlns=\"http://www.w3.org/1999/xhtml\">John</b>\n      </html:h1>\n   "
-          end
-        end
-
-        it "should reproduce test002" do
-          l = @new.call("
-    Ramifications of
-       <apply>
-      <power/>
-      <apply>
-	<plus/>
-	<ci>a</ci>
-	<ci>b</ci>
-      </apply>
-      <cn>2</cn>
-    </apply>
-    to World Peace
-  ",
-                      :datatype => RDF.XMLLiteral,
-                      :namespaces => {
-                        "" => "http://www.w3.org/TR/REC-mathml",
-                      })
-
-          l.to_s.should == "\n    Ramifications of\n       <apply xmlns=\"http://www.w3.org/TR/REC-mathml\">\n      <power></power>\n      <apply>\n\t<plus></plus>\n\t<ci>a</ci>\n\t<ci>b</ci>\n      </apply>\n      <cn>2</cn>\n    </apply>\n    to World Peace\n  "
-        end
-      end
-
-      context "rdfms-xmllang" do
-        it "should reproduce test001" do
-          l = @new.call("chat", :datatype => RDF.XMLLiteral, :language => nil)
-
-          l.to_s.should == "chat"
-        end
-        it "should reproduce test002" do
-          l = @new.call("chat", :datatype => RDF.XMLLiteral, :language => :fr)
-
-          l.to_s.should == "chat"
-        end
-      end
-
-      context "xml-canon" do
-        it "should reproduce test001" do
-          l = @new.call("<br />", :datatype => RDF.XMLLiteral)
-
-          l.to_s.should == "<br></br>"
-        end
-      end
-    end
-
-    context "rdfa tests" do
-      it "should reproduce test 0011: XMLLiteral" do
-        l = @new.call("E = mc<sup>2</sup>: The Most Urgent Problem of Our Time",
-                    :datatype => RDF.XMLLiteral,
-                    :namespaces => {"" => "http://www.w3.org/1999/xhtml"})
-
-        l.to_s.should == "E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\">2</sup>: The Most Urgent Problem of Our Time"
-      end
-
-      it "should reproduce test 0092: Tests XMLLiteral content with explicit @datatype" do
-        l = @new.call(%(E = mc<sup>2</sup>: The Most Urgent Problem of Our Time<),
-                    :datatype => RDF.XMLLiteral,
-                    :namespaces => {"" => "http://www.w3.org/1999/xhtml"})
-
-        l.to_s.should == "E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\">2</sup>: The Most Urgent Problem of Our Time"
-      end
-
-      it "should reproduce test 0100: XMLLiteral with explicit namespace" do
-        l = @new.call(%(Some text here in <strong>bold</strong> and an svg rectangle: <svg:svg><svg:rect svg:width="200" svg:height="100"/></svg:svg>),
-                    :datatype => RDF.XMLLiteral,
-                    :namespaces => {
-                      "" => "http://www.w3.org/1999/xhtml",
-                      "svg" => "http://www.w3.org/2000/svg",
-                    })
-
-        pending do
-          l.to_s.should == "Some text here in <strong xmlns=\"http://www.w3.org/1999/xhtml\">bold</strong> and an svg rectangle: <svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"><svg:rect svg:height=\"100\" svg:width=\"200\"></svg:rect></svg:svg>"
-        end
-      end
-
-      it "should reproduce 0101: XMLLiteral with explicit namespace and xml:lang" do
-        l = @new.call(%(Du texte ici en <strong>gras</strong> et un rectangle en svg: <svg:svg><svg:rect svg:width="200" svg:height="100"/></svg:svg>),
-                    :datatype => RDF.XMLLiteral, :language => :fr,
-                    :namespaces => {
-                      "" => "http://www.w3.org/1999/xhtml",
-                      "svg" => "http://www.w3.org/2000/svg",
-                    })
-
-        pending do
-          l.to_s.should == "Du texte ici en <strong xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"fr\">gras</strong> et un rectangle en svg: <svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\" xml:lang=\"fr\"><svg:rect svg:height=\"100\" svg:width=\"200\"></svg:rect></svg:svg>"
-        end
-      end
-
-      it "should reproduce test 0102: XMLLiteral with explicit namespace and xml:lang; not overwriting existing langs" do
-        l = @new.call(%(Du texte ici en <strong>gras</strong> et un rectangle en svg: <svg:svg xml:lang="hu"><svg:rect svg:width="200" svg:height="100"/></svg:svg>),
-                    :datatype => RDF.XMLLiteral, :language => :fr,
-                    :namespaces => {
-                      "" => "http://www.w3.org/1999/xhtml",
-                      "svg" => "http://www.w3.org/2000/svg",
-                    })
-
-        pending do
-          l.to_s.should == "Du texte ici en <strong xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"fr\">gras</strong> et un rectangle en svg: <svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\" xml:lang=\"hu\"><svg:rect svg:height=\"100\" svg:width=\"200\"></svg:rect></svg:svg>"
-        end
-      end
-
-      it "should reproduce test 0103: XMLLiteral with explicit namespace; not overwriting local namespaces" do
-        l = @new.call(%(Some text here in <strong>bold</strong> and an svg rectangle: <svg xmlns="http://www.w3.org/2000/svg"><rect width="200" height="100"/></svg>),
-                    :datatype => RDF.XMLLiteral,
-                    :namespaces => {
-                      "" => "http://www.w3.org/1999/xhtml",
-                      "svg" => "http://www.w3.org/2000/svg",
-                    })
-
-        pending do
-          l.to_s.should == "Some text here in <strong xmlns=\"http://www.w3.org/1999/xhtml\">bold</strong> and an svg rectangle: <svg xmlns=\"http://www.w3.org/2000/svg\"><rect height=\"100\" width=\"200\"></rect></svg>"
-        end
-      end
-    end
-  end if defined?(::Nokogiri)
-end