json-ld 0.1.6.1 → 0.3.0

data/spec/suite_helper.rb

@@ -60,130 +60,49 @@ module RDF::Util
 end
 
 module Fixtures
-  module JSONLDTest
+  module SuiteTest
     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 < JSON::LD::Resource
+      def self.open(file)
+        #puts "open: #{file}"
+        RDF::Util::File.open_file(file) do |f|
+          json = JSON.parse(f.read)
+          self.from_jsonld(json)
+        end
+      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)
+      # @param [Hash] json framed JSON-LD
+      # @return [Array<Manifest>]
+      def self.from_jsonld(json)
+        Manifest.new(json)
+      end
 
-            # 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
+      def entries
+        # Map entries to resources
+        attributes['sequence'].map do |e|
+          e.is_a?(String) ? Manifest.open("#{SUITE}#{e}") : Entry.new(e)
         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
+    class Entry < JSON::LD::Resource
       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)
+      # Base is expanded input file
+      def base
+        "#{SUITE}tests/#{property('input')}"
       end
 
-      def extra
-        RDF::Util::File.open_file(self.extraDocument)
-      end
-      
-      def expect
-        RDF::Util::File.open_file(self.resultDocument)
+      # Alias input, context, expect and frame
+      %w(input context expect frame).each do |m|
+        define_method(m.to_sym) {RDF::Util::File.open_file "#{SUITE}tests/#{property(m)}"}
       end
 
-      def base_uri
-        inputDocument.to_s
+      def positiveTest
+        property('positiveTest') == 'true'
       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
+      def trace; @debug.join("\n"); end
     end
-
-    repo = RDF::Repository.load(SUITE.join("manifest.jsonld"), :format => :jsonld)
-    Spira.add_repository! :default, repo
   end
 end

data/spec/suite_to_rdf_spec.rb

@@ -0,0 +1,76 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+
+describe JSON::LD do
+  describe "test suite" do
+    require 'suite_helper'
+    m = Fixtures::SuiteTest::Manifest.open('http://json-ld.org/test-suite/tests/toRdf-manifest.jsonld')
+    describe m.name do
+      m.entries.each do |t|
+        specify "#{t.property('input')}: #{t.name}" do
+          begin
+            t.debug = ["test: #{t.inspect}", "source: #{t.input.read}"]
+            quads = []
+            JSON::LD::API.toRDF(t.input, nil, nil,
+                                :base => t.base,
+                                :debug => t.debug) do |statement|
+              quads << to_quad(statement)
+            end
+
+            sorted_expected = t.expect.readlines.sort.join("")
+            quads.sort.join("").should produce(sorted_expected, t.debug)
+          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
+
+  # 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
+      case
+      when thing.object.nan?, thing.object.infinite?, thing.object.zero?
+        thing.canonicalize.to_ntriples
+      else
+        i, f, e = ('%.15E' % thing.object.to_f).split(/[\.E]/)
+        f.sub!(/0*$/, '')           # remove any trailing zeroes
+        f = '0' if f.empty?         # ...but there must be a digit to the right of the decimal point
+        e.sub!(/^\+?0+(\d)$/, '\1') # remove the optional leading '+' sign and any extra leading zeroes
+        %("#{i}.#{f}E#{e}"^^<http://www.w3.org/2001/XMLSchema#double>)
+      end
+    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 unless ENV['CI']

data/spec/to_rdf_spec.rb

@@ -96,6 +96,12 @@ describe JSON::LD::API do
           }),
           %q([ a <http://example.com/foo>, <http://example.com/baz> ] .)
         ],
+        "blank node type" => [
+          %q({
+            "@type": "_:foo"
+          }),
+          %q([ a _:a ] .)
+        ]
       }.each do |title, (js, nt)|
         it title do
           parse(js).should be_equivalent_graph(nt, :trace => @debug, :inputDocument => js)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-ld
 version: !ruby/object:Gem::Version
-  version: 0.1.6.1
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-24 00:00:00.000000000 Z
+date: 2012-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -242,6 +242,7 @@ files:
 - lib/json/ld/frame.rb
 - lib/json/ld/from_rdf.rb
 - lib/json/ld/reader.rb
+- lib/json/ld/resource.rb
 - lib/json/ld/to_rdf.rb
 - lib/json/ld/utils.rb
 - lib/json/ld/version.rb
@@ -257,9 +258,14 @@ files:
 - spec/from_rdf_spec.rb
 - spec/matchers.rb
 - spec/reader_spec.rb
+- spec/resource_spec.rb
 - spec/spec_helper.rb
+- spec/suite_compact_spec.rb
+- spec/suite_expand_spec.rb
+- spec/suite_frame_spec.rb
+- spec/suite_from_rdf_spec.rb
 - spec/suite_helper.rb
-- spec/suite_spec.rb
+- spec/suite_to_rdf_spec.rb
 - spec/support/extensions.rb
 - spec/to_rdf_spec.rb
 - spec/writer_spec.rb
@@ -356,9 +362,14 @@ test_files:
 - spec/from_rdf_spec.rb
 - spec/matchers.rb
 - spec/reader_spec.rb
+- spec/resource_spec.rb
 - spec/spec_helper.rb
+- spec/suite_compact_spec.rb
+- spec/suite_expand_spec.rb
+- spec/suite_frame_spec.rb
+- spec/suite_from_rdf_spec.rb
 - spec/suite_helper.rb
-- spec/suite_spec.rb
+- spec/suite_to_rdf_spec.rb
 - spec/support/extensions.rb
 - spec/to_rdf_spec.rb
 - spec/writer_spec.rb

data/spec/suite_spec.rb

@@ -1,105 +0,0 @@
-# coding: utf-8
-$:.unshift "."
-require 'spec_helper'
-
-describe JSON::LD do
-  describe "test suite" do
-    require 'suite_helper'
-    
-    if 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
-  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