rdf_context 0.4.2

data/spec/list_store_spec.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require File.join(File.dirname(__FILE__), 'store_helper')
+
+describe "List Store" do
+  before(:all) do
+      @identifier = URIRef.new("http://identifier")
+      @ctx = @identifier
+  end
+  
+  subject { ListStore.new(@identifier) }
+  it_should_behave_like "Store"
+end

data/spec/literal_spec.rb

@@ -0,0 +1,314 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Literals: " do
+  describe "an untyped string" do
+    subject {Literal.untyped("tom")}
+    it "should be equal if they have the same contents" do should == Literal.untyped("tom") end
+    it "should not be equal if they do not have the same contents" do should_not == Literal.untyped("tim") end
+    it "should match a string" do should == "tom" end
+    it "should return a string using to_s" do subject.to_s.should == "tom" end
+    
+    it "should infer type" do
+      other = Literal.build_from("foo")
+      other.encoding.should == "http://www.w3.org/2001/XMLSchema#string"
+    end
+    
+    describe "should handle specific cases" do
+      {
+        '"Gregg"' => Literal.untyped("Gregg"),
+        '"\u677E\u672C \u540E\u5B50"' => Literal.untyped("松本 后子"),
+        '"D\u00FCrst"' => Literal.untyped("Dürst")
+      }.each_pair do |encoded, literal|
+        it "should encode '#{literal.contents}'" do
+          literal.to_n3.should == encoded
+        end
+      end
+    end
+
+    describe "encodings" do
+      it "should return n3" do subject.to_n3.should == "\"tom\"" end
+      it "should return ntriples" do subject.to_ntriples.should == "\"tom\"" end
+      it "should return xml_args" do subject.xml_args.should == ["tom", {}] end
+      it "should return TriX" do subject.to_trix.should == "<plainLiteral>tom</plainLiteral>" end
+    end
+
+    describe "with extended characters" do
+      subject { Literal.untyped("松本 后子") }
+      
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == '"\u677E\u672C \u540E\u5B50"' end
+        it "should return ntriples" do subject.to_ntriples.should == '"\u677E\u672C \u540E\u5B50"' end
+        it "should return xml_args" do subject.xml_args.should == ["松本 后子", {}] end
+        it "should return TriX" do subject.to_trix.should == "<plainLiteral>" + "松本 后子" + "</plainLiteral>" end
+      end
+    end
+    
+    describe "with a language" do
+      subject { Literal.untyped("tom", "en") }
+
+      it "should accept a language tag" do
+        subject.lang.should == "en"
+      end
+  
+      it "should be equal if they have the same contents and language" do
+        should == Literal.untyped("tom", "en")
+      end
+  
+      it "should not be equal if they do not have the same contents" do
+        should_not == Literal.untyped("tim", "en")
+      end
+    
+      it "should not be equal if they do not have the same language" do
+        should_not == Literal.untyped("tom", "fr")
+      end
+
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == "\"tom\"@en" end
+        it "should return ntriples" do subject.to_ntriples.should == "\"tom\"@en" end
+        it "should return xml_args" do subject.xml_args.should == ["tom", {"xml:lang" => "en"}] end
+        it "should return TriX" do subject.to_trix.should == "<plainLiteral xml:lang=\"en\">tom</plainLiteral>" end
+      end
+
+      it "should normalize language tags to lower case" do
+        f = Literal.untyped("tom", "EN")
+        f.lang.should == "en"
+      end
+    end
+  end
+  
+  describe "a typed string" do
+    subject { Literal.typed("tom", "http://www.w3.org/2001/XMLSchema#string") }
+    
+    it "accepts an encoding" do
+      subject.encoding.to_s.should == "http://www.w3.org/2001/XMLSchema#string"
+    end
+
+    it "should be equal if they have the same contents and datatype" do
+      should == Literal.typed("tom", "http://www.w3.org/2001/XMLSchema#string")
+    end
+
+    it "should not be equal if they do not have the same contents" do
+      should_not == Literal.typed("tim", "http://www.w3.org/2001/XMLSchema#string")
+    end
+
+    it "should not be equal if they do not have the same datatype" do
+      should_not == Literal.typed("tom", "http://www.w3.org/2001/XMLSchema#token")
+    end
+
+    describe "encodings" do
+      it "should return n3" do subject.to_n3.should == "\"tom\"^^<http://www.w3.org/2001/XMLSchema#string>" end
+      it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+      it "should return xml_args" do subject.xml_args.should == ["tom", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#string"}] end
+      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#string\">tom</typedLiteral>" end
+    end
+  end
+  
+  describe "an integer" do
+    describe "encodings" do
+      subject { Literal.typed(5, "http://www.w3.org/2001/XMLSchema#int") }
+      it "should return n3" do subject.to_n3.should == "\"5\"^^<http://www.w3.org/2001/XMLSchema#int>" end
+      it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+      it "should return xml_args" do subject.xml_args.should == ["5", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#int"}] end
+      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#int\">5</typedLiteral>" end
+    end
+
+    it "should infer type" do
+      int = Literal.build_from(15)
+      int.encoding.should == "http://www.w3.org/2001/XMLSchema#int"
+    end
+  end
+    
+  describe "a float" do
+    describe "encodings" do
+      subject { Literal.typed(15.4, "http://www.w3.org/2001/XMLSchema#float") }
+      it "should return n3" do subject.to_n3.should == "\"15.4\"^^<http://www.w3.org/2001/XMLSchema#float>" end
+      it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+      it "should return xml_args" do subject.xml_args.should == ["15.4", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#float"}] end
+      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#float\">15.4</typedLiteral>" end
+    end
+
+    it "should infer type" do
+      float = Literal.build_from(15.4)
+      float.encoding.should == "http://www.w3.org/2001/XMLSchema#float"
+    end
+  end
+    
+  describe "XML Literal" do
+    describe "with no namespace" do
+      subject { Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral") }
+      it "should indicate xmlliteral?" do
+        subject.xmlliteral?.should == true
+      end
+      
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == "\"foo <sup>bar</sup> baz!\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+        it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+        it "should return xml_args" do subject.xml_args.should == ["foo <sup>bar</sup> baz!", {"rdf:parseType" => "Literal"}] end
+        it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup>bar</sup> baz!</typedLiteral>" end
+      end
+      
+      it "should be equal if they have the same contents" do
+        should == Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+      end
+
+      it "should be a XMLLiteral encoding" do
+        subject.encoding.should == "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"
+      end
+    end
+      
+    describe "with a namespace" do
+      subject {
+        Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                      :namespaces => {"dc" => Namespace.new("http://purl.org/dc/elements/1.1/", "dc")})
+      }
+    
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == "\"foo <sup>bar</sup> baz!\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+        it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+        it "should return xml_args" do subject.xml_args.should == ["foo <sup>bar</sup> baz!", {"rdf:parseType" => "Literal"}] end
+        it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup>bar</sup> baz!</typedLiteral>" end
+      end
+      
+      describe "and language" do
+        subject {
+          Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                        :namespaces => {"dc" => Namespace.new("http://purl.org/dc/elements/1.1/", "dc")},
+                        :language => "fr")
+        }
+
+        describe "encodings" do
+          it "should return n3" do subject.to_n3.should == "\"foo <sup xml:lang=\\\"fr\\\">bar</sup> baz!\"\^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+          it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+          it "should return xml_args" do subject.xml_args.should == ["foo <sup xml:lang=\"fr\">bar</sup> baz!", {"rdf:parseType" => "Literal"}] end
+          it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup xml:lang=\"fr\">bar</sup> baz!</typedLiteral>" end
+        end
+      end
+      
+      describe "and language with an existing language embedded" do
+        subject {
+          Literal.typed("foo <sup>bar</sup><sub xml:lang=\"en\">baz</sub>",
+                        "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                        :language => "fr")
+        }
+
+        describe "encodings" do
+          it "should return n3" do subject.to_n3.should == "\"foo <sup xml:lang=\\\"fr\\\">bar</sup><sub xml:lang=\\\"en\\\">baz</sub>\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+          it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+          it "should return xml_args" do subject.xml_args.should == ["foo <sup xml:lang=\"fr\">bar</sup><sub xml:lang=\"en\">baz</sub>", {"rdf:parseType" => "Literal"}] end
+          it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup xml:lang=\"fr\">bar</sup><sub xml:lang=\"en\">baz</sub></typedLiteral>" end
+        end
+      end
+      
+      describe "and namespaced element" 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/elements/1.1/"
+          	  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
+          Literal.typed(content,
+                        "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                        :namespaces => {
+                          "svg" => Namespace.new("http://www.w3.org/2000/svg", "svg"),
+                          "dc" => Namespace.new("http://purl.org/dc/elements/1.1/", "dc")
+                        })
+        }
+        it "should return xml_args" do subject.xml_args.should == ["<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"></svg:svg>", {"rdf:parseType" => "Literal"}] end
+      end
+      
+      describe "and existing namespace definition" do
+        subject {
+          Literal.typed("<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"/>",
+                        "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                        :namespaces => {"svg" => Namespace.new("http://www.w3.org/2000/svg", "svg")})
+        }
+        it "should return xml_args" do subject.xml_args.should == ["<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"></svg:svg>", {"rdf:parseType" => "Literal"}] end
+      end
+    end
+      
+    describe "with a default namespace" do
+      subject {
+        Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                      :namespaces => {"" => Namespace.new("http://purl.org/dc/elements/1.1/", "")})
+      }
+    
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == "\"foo <sup xmlns=\\\"http://purl.org/dc/elements/1.1/\\\">bar</sup> baz!\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+        it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+        it "should return xml_args" do subject.xml_args.should == ["foo <sup xmlns=\"http://purl.org/dc/elements/1.1/\">bar</sup> baz!", {"rdf:parseType" => "Literal"}] end
+        it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup xmlns=\"http://purl.org/dc/elements/1.1/\">bar</sup> baz!</typedLiteral>" end
+      end
+    end
+    
+    describe "with multiple namespaces" do
+      subject {
+        Literal.typed("foo <sup <sup xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+      }
+      it "should ignore namespace order" do
+        g = Literal.typed("foo <sup <sup xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+        should == g
+      end
+    end
+    
+    describe "with multiple attributes" do
+      it "should ignore attribute order" do
+        f = Literal.typed("foo <sup a=\"a\" b=\"b\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+        g = Literal.typed("foo <sup b=\"b\" a=\"a\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+        f.should == g
+      end
+    end
+  end
+  
+  describe "an n3 literal" do
+    {
+      "Gregg" => ['Gregg', nil, nil],
+      "Dürst" => ['D\u00FCrst', nil, nil],
+      "simple literal"  => ['simple literal', nil, nil],
+      "backslash:\\" => ['backslash:\\\\', nil, nil],
+      "dquote:\"" => ['dquote:\\"', nil, nil],
+      "newline:\n" => ['newline:\\n', nil, nil],
+      "return:\r" => ['return:\\r', nil, nil],
+      "tab:\t" => ['tab:\\t', nil, nil],
+    }.each_pair do |name, args|
+      specify "test #{name}" do
+        Literal.n3_encoded(*args).contents.should == name
+      end
+    end
+  end
+  
+#  it "build_from_language" do
+#    english = Literal.build_from_language("Have a nice day")
+#    english.encoding.should == "en"
+#    
+#    french = Literal.build_from_language("Bonjour, madame. Parlez vous francais?")
+#    french.encoding.should == "fr"
+#    
+#    german = Literal.build_from_language("Achtung")
+#    german.encoding.should == "de"
+#  end
+
+  # TODO: refactor based on new interface
+  # describe "Languages" do
+  #   it "should be inspectable" do
+  #     literal = RdfContext::Literal.new("foo", "en")
+  #     lang = literal.lang
+  #     lang.to_s == "en"
+  #     lang.hash.class.should == Fixnum
+  #   end    
+  # end
+  
+end

data/spec/matchers.rb

@@ -0,0 +1,150 @@
+require 'rdf/redland'
+
+module Matchers
+  class BeEquivalentGraph
+    def normalize(graph)
+      case graph
+      when Graph then graph
+      when Parser then graph.graph
+      else
+        triples = [graph].flatten.join("\n")
+        N3Parser.parse(graph.to_s, @info.about, :strict => true)
+      end
+    end
+    
+    def initialize(expected, info)
+      @info = info
+      @expected = normalize(expected)
+    end
+
+    def matches?(actual)
+      @actual = normalize(actual)
+      @actual == @expected
+    end
+
+    def failure_message_for_should
+      info = @info.respond_to?(:information) ? @info.information : ""
+      if @actual.size != @expected.size
+        "Graph entry count differs:\nexpected: #{@expected.size}\nactual:   #{@actual.size}"
+      elsif @actual.identifier != @expected.identifier
+        "Graph identifiers differ:\nexpected: #{@expected.identifier}\nactual:   #{@actual.identifier}"
+      else
+        "Graph differs\n"
+      end +
+      "\n\n#{info + "\n" unless info.empty?}" +
+      "Unsorted Expected:\n#{@expected.to_ntriples}" +
+      "Unsorted Results:\n#{@actual.to_ntriples}" +
+      (@info.respond_to?(:trace) ? "\nDebug:\n#{@info.trace}" : "")
+    end
+    def negative_failure_message
+      "Graphs do not differ\n"
+    end
+  end
+  
+  def be_equivalent_graph(expected, info = "")
+    BeEquivalentGraph.new(expected, info)
+  end
+
+  # Run expected SPARQL query against actual
+  class PassQuery
+    def initialize(expected, info)
+      @expected = expected
+      @query = Redland::Query.new(expected)
+      @info = info
+    end
+    def matches?(actual)
+      @actual = actual
+      @expected_results = @info.respond_to?(:expectedResults) ? @info.expectedResults : true
+      model = Redland::Model.new
+      ntriples_parser = Redland::Parser.ntriples
+      ntriples_parser.parse_string_into_model(model, actual.to_ntriples, "http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/")
+
+      @results = @query.execute(model)
+      if @expected_results
+        @results.is_boolean? && @results.get_boolean?
+      else
+        @results.nil? || @results.is_boolean? && !@results.get_boolean?
+      end
+    end
+    def failure_message_for_should
+      info = @info.respond_to?(:information) ? @info.information : ""
+      "#{info + "\n" unless info.empty?}" +
+      if @results.nil?
+        "Query failed to return results"
+      elsif !@results.is_boolean?
+        "Query returned non-boolean results"
+      elsif @expected_results
+        "Query returned false"
+      else
+        "Query returned true (expected false)"
+      end +
+      "\n#{@expected}" +
+      "\n#{@info.input}" +
+      "\nResults:\n#{@actual.to_ntriples}" +
+      "\nDebug:\n#{@info.trace}"
+    end
+  end
+
+  def pass_query(expected, info = "")
+    PassQuery.new(expected, info)
+  end
+
+  class BeValidXML
+    def initialize(info)
+      @info = info
+    end
+    def matches?(actual)
+      @actual = actual
+      @doc = Nokogiri::XML.parse(actual)
+      @results = @doc.validate
+      @results.nil?
+    rescue
+      false
+    end
+    def failure_message_for_should
+      "#{@info + "\n" unless @info.empty?}" +
+      if @doc.nil?
+        "did not parse"
+      else
+        "\n#{@results}" +
+        "\nParsed:\n#{@doc}"
+      end   +
+        "\nActual:\n#{@actual}"
+    end
+  end
+  
+  def be_valid_xml(info = "")
+    BeValidXML.new(info)
+  end
+
+  class BeEquivalentXML
+    def initialize(expected, info)
+      @expected = expected
+      @info = info
+    end
+    
+    def matches?(actual)
+      @actual = actual
+
+      a = "<foo>#{@actual}</foo>" unless @actual.index("<") == 0
+      e = "<foo>#{@expected}</foo>" unless @actual.index("<") == 0
+      a_hash = ActiveSupport::XmlMini.parse(a)
+      e_hash = ActiveSupport::XmlMini.parse(e)
+      a_hash == e_hash
+    rescue
+      @fault = $!.message
+      false
+    end
+
+    def failure_message_for_should
+      "#{@info + "\n" unless @info.empty?}" +
+      "#{@fault + "\n" unless @fault.nil?}" +
+      "Expected:\n#{@expected}\n" +
+      "Actual:#{@actual}"
+    end
+  end
+  
+  def be_equivalent_xml(expected, info = "")
+    BeEquivalentXML.new(expected, info)
+  end
+end