json-ld 0.1.3 → 0.1.4

data/spec/from_rdf_spec.rb

@@ -0,0 +1,316 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+require 'rdf/spec/writer'
+
+describe JSON::LD::API do
+  describe ".fromRDF" do
+    context "simple tests" do
+      it "One subject IRI object" do
+        input = %(<http://a/b> <http://a/c> <http://a/d> .)
+        serialize(input).should produce([
+        {
+          '@id'         => "http://a/b",
+          "http://a/c"  => [{"@id" => "http://a/d"}]
+        }], @debug)
+      end
+
+      it "should generate object list" do
+        input = %(@prefix : <http://example.com/> . :b :c :d, :e .)
+        serialize(input).
+        should produce([{
+          '@id'                         => "http://example.com/b",
+          "http://example.com/c" => [
+            {"@id" => "http://example.com/d"},
+            {"@id" => "http://example.com/e"}
+          ]
+        }], @debug)
+      end
+    
+      it "should generate property list" do
+        input = %(@prefix : <http://example.com/> . :b :c :d; :e :f .)
+        serialize(input).
+        should produce([{
+          '@id'   => "http://example.com/b",
+          "http://example.com/c"      => [{"@id" => "http://example.com/d"}],
+          "http://example.com/e"      => [{"@id" => "http://example.com/f"}]
+        }], @debug)
+      end
+    
+      it "serializes multiple subjects" do
+        input = %q(
+          @prefix : <http://www.w3.org/2006/03/test-description#> .
+          @prefix dc: <http://purl.org/dc/elements/1.1/> .
+          <test-cases/0001> a :TestCase .
+          <test-cases/0002> a :TestCase .
+        )
+        serialize(input).
+        should produce([
+          {'@id'  => "test-cases/0001", '@type' => ["http://www.w3.org/2006/03/test-description#TestCase"]},
+          {'@id'  => "test-cases/0002", '@type' => ["http://www.w3.org/2006/03/test-description#TestCase"]}
+        ], @debug)
+      end
+    end
+  
+    context "literals" do
+      it "coerces typed literal" do
+        input = %(@prefix ex: <http://example.com/> . ex:a ex:b "foo"^^ex:d .)
+        serialize(input).should produce([{
+          '@id'   => "http://example.com/a",
+          "http://example.com/b"    => [{"@value" => "foo", "@type" => "http://example.com/d"}]
+        }], @debug)
+      end
+
+      it "coerces integer" do
+        input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1 .)
+        serialize(input).should produce([{
+          '@id'   => "http://example.com/a",
+          "http://example.com/b"    => [{"@value" => "1","@type" => "http://www.w3.org/2001/XMLSchema#integer"}]
+        }], @debug)
+      end
+
+      it "coerces boolean" do
+        input = %(@prefix ex: <http://example.com/> . ex:a ex:b true .)
+        serialize(input).should produce([{
+          '@id'   => "http://example.com/a",
+          "http://example.com/b"    => [{"@value" => "true","@type" => "http://www.w3.org/2001/XMLSchema#boolean"}]
+        }], @debug)
+      end
+
+      it "coerces decmal" do
+        input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1.0 .)
+        serialize(input).should produce([{
+          '@id'   => "http://example.com/a",
+          "http://example.com/b"    => [{"@value" => "1.0", "@type" => "http://www.w3.org/2001/XMLSchema#decimal"}]
+        }], @debug)
+      end
+
+      it "coerces double" do
+        input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1.0e0 .)
+        serialize(input).should produce([{
+          '@id'   => "http://example.com/a",
+          "http://example.com/b"    => [{"@value" => "1.0E0","@type" => "http://www.w3.org/2001/XMLSchema#double"}]
+        }], @debug)
+      end
+    
+      it "encodes language literal" do
+        input = %(@prefix ex: <http://example.com/> . ex:a ex:b "foo"@en-us .)
+        serialize(input).should produce([{
+          '@id'   => "http://example.com/a",
+          "http://example.com/b"    => [{"@value" => "foo", "@language" => "en-us"}]
+        }], @debug)
+      end
+    end
+
+    context "anons" do
+      it "should generate bare anon" do
+        input = %(@prefix : <http://example.com/> . _:a :a :b .)
+        serialize(input).should produce([{
+          "@id" => "_:a",
+          "http://example.com/a"  => [{"@id" => "http://example.com/b"}]
+        }], @debug)
+      end
+    
+      it "should generate anon as object" do
+        input = %(@prefix : <http://example.com/> . :a :b _:a . _:a :c :d .)
+        serialize(input).should produce([
+          {
+            "@id" => "_:a",
+            "http://example.com/c"  => [{"@id" => "http://example.com/d"}]
+          },
+          {
+            "@id" => "http://example.com/a",
+            "http://example.com/b"  => [{"@id" => "_:a"}]
+          },
+        ], @debug)
+      end
+    end
+  
+    context "lists" do
+      it "should generate literal list" do
+        input = %(
+          @prefix : <http://example.com/> .
+          @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+          :a :b ("apple" "banana")  .
+        )
+        serialize(input).should produce([{
+          '@id'   => "http://example.com/a",
+          "http://example.com/b"  => [{
+            "@list" => [
+              {"@value" => "apple"},
+              {"@value" => "banana"}
+            ]
+          }]
+        }], @debug)
+      end
+    
+      it "should generate iri list" do
+        input = %(@prefix : <http://example.com/> . :a :b (:c) .)
+        serialize(input).should produce([{
+          '@id'   => "http://example.com/a",
+          "http://example.com/b"  => [{
+            "@list" => [
+              {"@id" => "http://example.com/c"}
+            ]
+          }]
+        }], @debug)
+      end
+    
+      it "should generate empty list" do
+        input = %(@prefix : <http://example.com/> . :a :b () .)
+        serialize(input).should produce([{
+          '@id'   => "http://example.com/a",
+          "http://example.com/b"  => [{"@list" => []}]
+        }], @debug)
+      end
+    
+      it "should generate single element list" do
+        input = %(@prefix : <http://example.com/> . :a :b ( "apple" ) .)
+        serialize(input).should produce([{
+          '@id'   => "http://example.com/a",
+          "http://example.com/b"  => [{"@list" => [{"@value" => "apple"}]}]
+        }], @debug)
+      end
+    
+      it "should generate single element list without @type" do
+        input = %(
+        @prefix : <http://example.com/> . :a :b ( _:a ) . _:a :b "foo" .)
+        serialize(input).should produce([
+          {
+            '@id'   => "_:a",
+            "http://example.com/b"  => [{"@value" => "foo"}]
+          },
+          {
+            '@id'   => "http://example.com/a",
+            "http://example.com/b"  => [{"@list" => [{"@id" => "_:a"}]}]
+          },
+        ], @debug)
+      end
+    end
+    
+    context "quads" do
+      {
+        "simple named graph" => {
+          :input => %(
+            <http://example.com/a> <http://example.com/b> <http://example.com/c> <http://example.com/U> .
+          ),
+          :output => [
+            {
+              "@id" => "http://example.com/U",
+              "@graph" => [{
+                "@id" => "http://example.com/a",
+                "http://example.com/b" => [{"@id" => "http://example.com/c"}]
+              }]
+            }
+          ]
+        },
+        "with properties" => {
+          :input => %(
+            <http://example.com/a> <http://example.com/b> <http://example.com/c> <http://example.com/U> .
+            <http://example.com/U> <http://example.com/d> <http://example.com/e> .
+          ),
+          :output => [
+            {
+              "@id" => "http://example.com/U",
+              "@graph" => [{
+                "@id" => "http://example.com/a",
+                "http://example.com/b" => [{"@id" => "http://example.com/c"}]
+              }],
+              "http://example.com/d" => [{"@id" => "http://example.com/e"}]
+            }
+          ]
+        },
+        "with lists" => {
+          :input => %(
+            <http://example.com/a> <http://example.com/b> _:a <http://example.com/U> .
+            _:a <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://example.com/c> <http://example.com/U> .
+            _:a <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> <http://example.com/U> .
+            <http://example.com/U> <http://example.com/d> _:b .
+            _:b <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://example.com/e> .
+            _:b <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+          ),
+          :output => [
+            {
+              "@id" => "http://example.com/U",
+              "@graph" => [{
+                "@id" => "http://example.com/a",
+                "http://example.com/b" => [{"@list" => [{"@id" => "http://example.com/c"}]}]
+              }],
+              "http://example.com/d" => [{"@list" => [{"@id" => "http://example.com/e"}]}]
+            }
+          ]
+        },
+        "Two Graphs with same subject and lists" => {
+          :input => %(
+            <http://example.com/a> <http://example.com/b> _:a <http://example.com/U> .
+            _:a <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://example.com/c> <http://example.com/U> .
+            _:a <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> <http://example.com/U> .
+            <http://example.com/a> <http://example.com/b> _:b <http://example.com/V> .
+            _:b <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://example.com/e> <http://example.com/V> .
+            _:b <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> <http://example.com/V> .
+          ),
+          :output => [
+            {
+              "@id" => "http://example.com/U",
+              "@graph" => [
+                {
+                  "@id" => "http://example.com/a",
+                  "http://example.com/b" => [{
+                    "@list" => [{"@id" => "http://example.com/c"}]
+                  }]
+                }
+              ]
+            },
+            {
+              "@id" => "http://example.com/V",
+              "@graph" => [
+                {
+                  "@id" => "http://example.com/a",
+                  "http://example.com/b" => [{
+                    "@list" => [{"@id" => "http://example.com/e"}]
+                  }]
+                }
+              ]
+            }
+          ]
+        },
+      }.each_pair do |name, properties|
+        it name do
+          r = serialize(properties[:input], :reader => RDF::NQuads::Reader)
+          r.should produce(properties[:output], @debug)
+        end
+      end
+    end
+
+    context "notType option" do
+      it "uses @type if set to false" do
+        input = %(@prefix ex: <http://example.com/> . ex:a a ex:b .)
+        serialize(input, :notType => false).should produce([{
+          '@id'   => "http://example.com/a",
+          "@type"    => ["http://example.com/b"]
+        }], @debug)
+      end
+      
+      it "does not use @type if set to true" do
+        input = %(@prefix ex: <http://example.com/> . ex:a a ex:b .)
+        serialize(input, :notType => true).should produce([{
+          '@id'   => "http://example.com/a",
+          RDF.type.to_s    => [{"@id" => "http://example.com/b"}]
+        }], @debug)
+      end
+    end
+  end
+
+  def parse(input, options = {})
+    reader = options[:reader] || RDF::Turtle::Reader
+    RDF::Repository.new << reader.new(input, options)
+  end
+
+  # Serialize ntstr to a string and compare against regexps
+  def serialize(ntstr, options = {})
+    g = ntstr.is_a?(String) ? parse(ntstr, options) : ntstr
+    @debug = [] << g.dump(:trig)
+    statements = g.each_statement.to_a
+    JSON::LD::API.fromRDF(statements, nil, options.merge(:debug => @debug))
+  end
+end

data/spec/matchers.rb

@@ -0,0 +1,67 @@
+require 'rdf/isomorphic'
+require 'rspec/matchers'
+require 'json'
+
+Info = Struct.new(:about, :information, :trace, :inputDocument, :outputDocument, :expectedResults)
+
+def normalize(graph)
+  case graph
+  when RDF::Graph then graph
+  when IO, StringIO
+    RDF::Graph.new.load(graph, :base => @info.about)
+  else
+    # Figure out which parser to use
+    g = RDF::Graph.new
+    reader_class = detect_format(graph)
+    reader_class.new(graph, :base => @info.about).each {|s| g << s}
+    g
+  end
+end
+
+RSpec::Matchers.define :be_equivalent_graph do |expected, info|
+  match do |actual|
+    @info = if info.respond_to?(:about)
+      info
+    elsif info.is_a?(Hash)
+      identifier = info[:identifier] || expected.is_a?(RDF::Graph) ? expected.context : info[:about]
+      trace = info[:trace]
+      trace = trace.join("\n") if trace.is_a?(Array)
+      Info.new(identifier, info[:information] || "", trace, info[:inputDocument])
+    else
+      Info.new(expected.is_a?(RDF::Graph) ? expected.context : info, info.to_s)
+    end
+    @expected = normalize(expected)
+    @actual = normalize(actual)
+    @actual.isomorphic_with?(@expected)
+  end
+  
+  failure_message_for_should do |actual|
+    info = @info.respond_to?(:information) ? @info.information : @info.inspect
+    if @expected.is_a?(RDF::Graph) && @actual.size != @expected.size
+      "Graph entry count differs:\nexpected: #{@expected.size}\nactual:   #{@actual.size}"
+    elsif @expected.is_a?(Array) && @actual.size != @expected.length
+      "Graph entry count differs:\nexpected: #{@expected.length}\nactual:   #{@actual.size}"
+    else
+      "Graph differs"
+    end +
+    "\n#{info + "\n" unless info.empty?}" +
+    "Unsorted Expected:\n#{@expected.dump(:nquads, :standard_prefixes => true)}" +
+    "Unsorted Results:\n#{@actual.dump(:nquads, :standard_prefixes => true)}" +
+    (@info.inputDocument ? "Input file: #{@info.inputDocument}\n" : "") +
+    (@info.outputDocument ? "Output file: #{@info.outputDocument}\n" : "") +
+    (@info.trace ? "\nDebug:\n#{@info.trace}" : "")
+  end  
+end
+
+RSpec::Matchers.define :produce do |expected, info|
+  match do |actual|
+    actual.should == expected
+  end
+  
+  failure_message_for_should do |actual|
+    "Expected: #{expected.is_a?(String) ? expected : expected.to_json(JSON_STATE)}\n" +
+    "Actual  : #{actual.is_a?(String) ? actual : actual.to_json(JSON_STATE)}\n" +
+    #(expected.is_a?(Hash) && actual.is_a?(Hash) ? "Diff: #{expected.diff(actual).to_json(JSON_STATE)}\n" : "") +
+    "Processing results:\n#{info.join("\n")}"
+  end
+end

data/spec/reader_spec.rb

@@ -0,0 +1,79 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+require 'rdf/spec/reader'
+
+describe JSON::LD::Reader do
+  before :each do
+    @reader = JSON::LD::Reader.new(StringIO.new(""))
+  end
+
+  it_should_behave_like RDF_Reader
+
+  describe ".for" do
+    formats = [
+      :jsonld,
+      "etc/doap.jsonld",
+      {:file_name      => 'etc/doap.jsonld'},
+      {:file_extension => 'jsonld'},
+      {:content_type   => 'application/ld+json'},
+      {:content_type   => 'application/x-ld+json'},
+    ].each do |arg|
+      it "discovers with #{arg.inspect}" do
+        RDF::Reader.for(arg).should == JSON::LD::Reader
+      end
+    end
+  end
+
+  context :interface do
+    subject { %q({
+      "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
+       "@id": "_:bnode1",
+       "@type": "foaf:Person",
+       "foaf:homepage": "http://example.com/bob/",
+       "foaf:name": "Bob"
+     }) }
+
+    describe "#initialize" do
+      it "yields reader given string" do
+        inner = mock("inner")
+        inner.should_receive(:called).with(JSON::LD::Reader)
+        JSON::LD::Reader.new(subject) do |reader|
+          inner.called(reader.class)
+        end
+      end
+
+      it "yields reader given IO" do
+        inner = mock("inner")
+        inner.should_receive(:called).with(JSON::LD::Reader)
+        JSON::LD::Reader.new(StringIO.new(subject)) do |reader|
+          inner.called(reader.class)
+        end
+      end
+
+      it "returns reader" do
+        JSON::LD::Reader.new(subject).should be_a(JSON::LD::Reader)
+      end
+    end
+
+    describe "#each_statement" do
+      it "yields statements" do
+        inner = mock("inner")
+        inner.should_receive(:called).with(RDF::Statement).exactly(3)
+        JSON::LD::Reader.new(subject).each_statement do |statement|
+          inner.called(statement.class)
+        end
+      end
+    end
+
+    describe "#each_triple" do
+      it "yields statements" do
+        inner = mock("inner")
+        inner.should_receive(:called).exactly(3)
+        JSON::LD::Reader.new(subject).each_triple do |subject, predicate, object|
+          inner.called(subject.class, predicate.class, object.class)
+        end
+      end
+    end
+  end
+end