json-ld 0.1.3 → 0.1.4

data/spec/spec_helper.rb

@@ -0,0 +1,56 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift File.dirname(__FILE__)
+
+require "bundler/setup"
+require 'rspec'
+require 'rdf'
+require 'rdf/isomorphic'
+require 'json/ld'
+require 'rdf/nquads'
+require 'rdf/turtle'
+require 'rdf/trig'
+require 'rdf/spec'
+require 'rdf/spec/matchers'
+require 'yaml'
+require 'open-uri/cached'
+require 'matchers'
+
+JSON_STATE = JSON::State.new(
+  :indent       => "  ",
+  :space        => " ",
+  :space_before => "",
+  :object_nl    => "\n",
+  :array_nl     => "\n"
+)
+
+# Create and maintain a cache of downloaded URIs
+URI_CACHE = File.expand_path(File.join(File.dirname(__FILE__), "uri-cache"))
+Dir.mkdir(URI_CACHE) unless File.directory?(URI_CACHE)
+OpenURI::Cache.class_eval { @cache_path = URI_CACHE }
+
+::RSpec.configure do |c|
+  c.filter_run :focus => true
+  c.run_all_when_everything_filtered = true
+  c.exclusion_filter = {
+    :ruby => lambda { |version| !(RUBY_VERSION.to_s =~ /^#{version.to_s}/) },
+  }
+  c.include(RDF::Spec::Matchers)
+end
+
+# Heuristically detect the input stream
+def detect_format(stream)
+  # Got to look into the file to see
+  if stream.is_a?(IO) || stream.is_a?(StringIO)
+    stream.rewind
+    string = stream.read(1000)
+    stream.rewind
+  else
+    string = stream.to_s
+  end
+  case string
+  when /<html/i           then RDF::RDFa::Reader
+  when /\{\s*\"@\"/i      then JSON::LD::Reader
+  else                         RDF::Turtle::Reader
+  end
+end
+

data/spec/suite_helper.rb

@@ -0,0 +1,184 @@
+# Spira class for manipulating test-manifest style test suites.
+# Used for SWAP tests
+require 'spira'
+require 'json/ld'
+require 'open-uri'
+require 'support/extensions'
+
+# For now, override RDF::Utils::File.open_file to look for the file locally before attempting to retrieve it
+module RDF::Util
+  module File
+    REMOTE_PATH = "http://json-ld.org/test-suite/"
+    LOCAL_PATH = ::File.expand_path("../json-ld.org/test-suite", __FILE__) + '/'
+
+    ##
+    # Override to use Patron for http and https, Kernel.open otherwise.
+    #
+    # @param [String] filename_or_url to open
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [Array, String] :headers
+    #   HTTP Request headers.
+    # @return [IO] File stream
+    # @yield [IO] File stream
+    def self.open_file(filename_or_url, options = {}, &block)
+      case filename_or_url.to_s
+      when /^file:/
+        path = filename_or_url[5..-1]
+        Kernel.open(path.to_s, &block)
+      when /^#{REMOTE_PATH}/
+        #puts "attempt to open #{filename_or_url} locally"
+        if response = ::File.open(filename_or_url.to_s.sub(REMOTE_PATH, LOCAL_PATH))
+          #puts "use #{filename_or_url} locally"
+          case filename_or_url.to_s
+          when /\.jsonld$/
+            def response.content_type; 'application/ld+json'; end
+          when /\.sparql$/
+            def response.content_type; 'application/sparql-query'; end
+          end
+
+          if block_given?
+            begin
+              yield response
+            ensure
+              response.close
+            end
+          else
+            response
+          end
+        else
+          Kernel.open(filename_or_url.to_s, &block)
+        end
+      else
+      end
+    end
+  end
+end
+
+module Fixtures
+  module JSONLDTest
+    SUITE = RDF::URI("http://json-ld.org/test-suite/")
+    class Test < RDF::Vocabulary("http://www.w3.org/2006/03/test-description#"); end
+    class Jld < RDF::Vocabulary("http://json-ld.org/test-suite/vocab#"); end
+
+    class Manifest < Spira::Base
+      type Jld.Manifest
+      property :name,       :predicate => RDF::DC.title,         :type => XSD.string
+      property :comment,    :predicate => RDF::RDFS.comment,  :type => XSD.string
+      property :sequence,   :predicate => Jld.sequence
+      
+      def entries
+        @entries ||= begin
+          repo = self.class.repository
+          RDF::List.new(sequence, repo).map do |entry|
+            results = repo.query(:subject => entry, :predicate => RDF.type)
+            entry_types = results.map(&:object)
+
+            # Load entry if it is not in repo
+            if entry_types.empty?
+              repo.load(entry, :format => :jsonld)
+              entry_types = repo.query(:subject => entry, :predicate => RDF.type).map(&:object)
+            end
+          
+            case 
+            when entry_types.include?(Jld.Manifest) then entry.as(Manifest)
+            when entry_types.include?(Jld.CompactTest) then entry.as(CompactTest)
+            when entry_types.include?(Jld.ExpandTest) then entry.as(ExpandTest)
+            when entry_types.include?(Jld.FrameTest) then entry.as(FrameTest)
+            when entry_types.include?(Jld.NormalizeTest) then entry.as(NormalizeTest)
+            when entry_types.include?(Jld.ToRDFTest) then entry.as(ToRDFTest)
+            when entry_types.include?(Jld.FromRDFTest) then entry.as(FromRDFTest)
+            when entry_types.include?(Test.TestCase) then entry.as(Entry)
+            else raise "Unexpected entry type: #{entry_types.inspect}"
+            end
+          end
+        end
+      end
+      
+      def inspect
+        "[#{self.class.to_s} " + %w(
+          subject
+          name
+        ).map {|a| v = self.send(a); "#{a}='#{v}'" if v}.compact.join(", ") +
+        ", entries=#{entries.length}" +
+        "]"
+      end
+    end
+
+    class Entry
+      attr_accessor :debug
+      include Spira::Resource
+      type Test.TestCase
+
+      property :name,           :predicate => RDF::DC.title,                :type => XSD.string
+      property :purpose,        :predicate => Test.purpose,                 :type => XSD.string
+      property :expected,       :predicate => Test.expectedResults
+      property :inputDocument,  :predicate => Test.informationResourceInput
+      property :resultDocument, :predicate => Test.informationResourceResults
+      property :extraDocument,  :predicate => Test.input
+
+      def information; name; end
+
+      def input
+        RDF::Util::File.open_file(self.inputDocument)
+      end
+
+      def extra
+        RDF::Util::File.open_file(self.extraDocument)
+      end
+      
+      def expect
+        RDF::Util::File.open_file(self.resultDocument)
+      end
+
+      def base_uri
+        inputDocument.to_s
+      end
+      
+      def trace
+        @debug.to_a.join("\n")
+      end
+
+      def inspect
+        "[#{self.class.to_s} " + %w(
+          subject
+          name
+          inputDocument
+          resultDocument
+          extraDocument
+        ).map {|a| v = self.send(a); "#{a}='#{v}'" if v}.compact.join(", ") +
+        "]"
+      end
+    end
+
+    class CompactTest < Entry
+      type Jld.CompactTest
+    end
+
+    class ExpandTest < Entry
+      type Jld.ExpandTest
+    end
+
+    class FrameTest < Entry
+      type Jld.FameTest
+    end
+
+    class NormalizeTest < Entry
+      type Jld.NormalizeTest
+    end
+
+    class FromRDFTest < Entry
+      type Jld.FromRDFTest
+    end
+
+    class ToRDFTest < Entry
+      type Jld.ToRDFTest
+
+      def quads
+        RDF::Util::File.open_file(self.expected)
+      end
+    end
+
+    repo = RDF::Repository.load(SUITE.join("manifest.jsonld"), :format => :jsonld)
+    Spira.add_repository! :default, repo
+  end
+end

data/spec/suite_spec.rb

@@ -0,0 +1,104 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+
+describe JSON::LD do
+  describe "test suite" do
+    require 'suite_helper'
+    
+    m = Fixtures::JSONLDTest::Manifest.each.to_a.first
+    describe m.name do
+      m.entries.each do |m2|
+        describe m2.name do
+          m2.entries.each do |t|
+            next if t.is_a?(Fixtures::JSONLDTest::NormalizeTest)
+            specify "#{File.basename(t.inputDocument.to_s)}: #{t.name}" do
+              begin
+                t.debug = ["test: #{t.inspect}", "source: #{t.input.read}"]
+                case t
+                when Fixtures::JSONLDTest::CompactTest
+                  t.debug << "context: #{t.extra.read}" if t.extraDocument
+                  result = JSON::LD::API.compact(t.input, t.extra, nil,
+                                                :base => t.base_uri,
+                                                :debug => t.debug)
+                  expected = JSON.load(t.expect)
+                  result.should produce(expected, t.debug)
+                when Fixtures::JSONLDTest::ExpandTest
+                  t.debug << "context: #{t.extra.read}" if t.extraDocument
+                  result = JSON::LD::API.expand(t.input, nil, nil,
+                                                :base => t.base_uri,
+                                                :debug => t.debug)
+                  expected = JSON.load(t.expect)
+                  result.should produce(expected, t.debug)
+                when Fixtures::JSONLDTest::FrameTest
+                  t.debug << "frame: #{t.extra.read}" if t.extraDocument
+                  result = JSON::LD::API.frame(t.input, t.extra, nil, 
+                                                :base => t.inputDocument,
+                                                :debug => t.debug)
+                  expected = JSON.load(t.expect)
+                  result.should produce(expected, t.debug)
+                when Fixtures::JSONLDTest::FromRDFTest
+                  repo = RDF::Repository.load(t.inputDocument)
+                  result = JSON::LD::API.fromRDF(repo.each_statement.to_a, nil,
+                                                :debug => t.debug)
+                  expected = JSON.load(t.expect)
+                  result.should produce(expected, t.debug)
+                when Fixtures::JSONLDTest::ToRDFTest
+                  quads = []
+                  JSON::LD::API.toRDF(t.input, nil, nil,
+                                      :base => t.inputDocument,
+                                      :debug => t.debug) do |statement|
+                    quads << to_quad(statement)
+                  end
+
+                  quads.sort.join("").should produce(t.expect.read, t.debug)
+                else
+                  pending("unkown test type #{t.inspect}")
+                end
+              rescue JSON::LD::ProcessingError => e
+                fail("Processing error: #{e.message}")
+              rescue JSON::LD::InvalidContext => e
+                fail("Invalid Context: #{e.message}")
+              rescue JSON::LD::InvalidFrame => e
+                fail("Invalid Frame: #{e.message}")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  # Don't use NQuads writer so that we don't escape Unicode
+  def to_quad(thing)
+    case thing
+    when RDF::URI
+      "<#{escaped(thing.to_s)}>"
+    when RDF::Node
+      escaped(thing.to_s)
+    when RDF::Literal::Double
+      quoted("%1.15e" % thing.value) + "^^<#{RDF::XSD.double}>"
+    when RDF::Literal
+      quoted(escaped(thing.value)) +
+      (thing.datatype? ? "^^<#{thing.datatype}>" : "") +
+      (thing.language? ? "@#{thing.language}" : "")
+    when RDF::Statement
+      thing.to_quad.map {|r| to_quad(r)}.compact.join(" ") + " .\n"
+    end
+  end
+
+  ##
+  # @param  [String] string
+  # @return [String]
+  def quoted(string)
+    "\"#{string}\""
+  end
+
+  ##
+  # @param  [String] string
+  # @return [String]
+  def escaped(string)
+    string.gsub('\\', '\\\\').gsub("\t", '\\t').
+      gsub("\n", '\\n').gsub("\r", '\\r').gsub('"', '\\"')
+  end
+end

data/spec/support/extensions.rb

@@ -0,0 +1,10 @@
+class Hash
+  def diff(other)
+    self.keys.inject({}) do |memo, key|
+      unless self[key] == other[key]
+        memo[key] = [self[key], other[key]] 
+      end
+      memo
+    end
+  end
+end

data/spec/test-files/test-1-automatic.json

@@ -0,0 +1,10 @@
+{
+  "@context": {
+    "avatar": "http://xmlns.com/foaf/0.1/avatar",
+    "homepage": "http://xmlns.com/foaf/0.1/homepage",
+    "name": "http://xmlns.com/foaf/0.1/name"
+  },
+  "avatar": "http://twitter.com/account/profile_image/manusporny",
+  "homepage": "http://manu.sporny.org/",
+  "name": "Manu Sporny"
+}

data/spec/test-files/test-1-compacted.json

@@ -0,0 +1,10 @@
+{
+    "@context": {
+        "avatar": "http://xmlns.com/foaf/0.1/avatar",
+        "homepage": "http://xmlns.com/foaf/0.1/homepage",
+        "name": "http://xmlns.com/foaf/0.1/name"
+    },
+    "avatar": "http://twitter.com/account/profile_image/manusporny",
+    "homepage": "http://manu.sporny.org/",
+    "name": "Manu Sporny"
+}

data/spec/test-files/test-1-context.json

@@ -0,0 +1,7 @@
+{
+  "@context": {
+    "name": "http://xmlns.com/foaf/0.1/name",
+    "homepage": "http://xmlns.com/foaf/0.1/homepage",
+    "avatar": "http://xmlns.com/foaf/0.1/avatar"
+  }
+}

data/spec/test-files/test-1-expanded.json

@@ -0,0 +1,5 @@
+[{
+    "http://xmlns.com/foaf/0.1/name": [{"@value": "Manu Sporny"}],
+    "http://xmlns.com/foaf/0.1/homepage": [{"@value": "http://manu.sporny.org/"}],
+    "http://xmlns.com/foaf/0.1/avatar": [{"@value": "http://twitter.com/account/profile_image/manusporny"}]
+}]

data/spec/test-files/test-1-input.json

@@ -0,0 +1,10 @@
+{
+  "@context": {
+    "name": "http://xmlns.com/foaf/0.1/name",
+    "homepage": "http://xmlns.com/foaf/0.1/homepage",
+    "avatar": "http://xmlns.com/foaf/0.1/avatar"
+  },
+  "name": "Manu Sporny",
+  "homepage": "http://manu.sporny.org/",
+  "avatar": "http://twitter.com/account/profile_image/manusporny"
+}

data/spec/test-files/test-1-normalized.json

@@ -0,0 +1,8 @@
+[{
+    "@id": {
+        "@id": "_:c14n0"
+    },
+    "http://xmlns.com/foaf/0.1/avatar": "http://twitter.com/account/profile_image/manusporny",
+    "http://xmlns.com/foaf/0.1/homepage": "http://manu.sporny.org/",
+    "http://xmlns.com/foaf/0.1/name": "Manu Sporny"
+}]

data/spec/test-files/test-1-rdf.ttl

@@ -0,0 +1,7 @@
+@prefix avatar: <http://xmlns.com/foaf/0.1/avatar> .
+@prefix homepage: <http://xmlns.com/foaf/0.1/homepage> .
+@prefix name: <http://xmlns.com/foaf/0.1/name> .
+
+ [ avatar: "http://twitter.com/account/profile_image/manusporny";
+    homepage: "http://manu.sporny.org/";
+    name: "Manu Sporny"] .

data/spec/test-files/test-2-automatic.json

@@ -0,0 +1,27 @@
+{
+  "@context": [
+    {
+      "dc": "http://purl.org/dc/elements/1.1/",
+      "ex": "http://example.org/vocab#"
+    },
+    {
+      "ex:contains": {
+        "@coerce": "@id"
+      }
+    }
+  ],
+  "@id": "http://example.org/library",
+  "@type": "ex:Library",
+  "ex:contains": {
+    "@id": "http://example.org/library/the-republic",
+    "@type": "ex:Book",
+    "dc:creator": "Plato",
+    "dc:title": "The Republic",
+    "ex:contains": {
+      "@id": "http://example.org/library/the-republic#introduction",
+      "@type": "ex:Chapter",
+      "dc:description": "An introductory chapter on The Republic.",
+      "dc:title": "The Introduction"
+    }
+  }
+}