json-ld 0.1.5.2 → 0.1.6

data/lib/json/ld/from_rdf.rb

@@ -11,13 +11,13 @@ module JSON::LD
     # @param [Array<RDF::Statement>, RDF::Enumerable] input
     # @return [Array<Hash>] the JSON-LD document in normalized form
     def from_statements(input)
-      defaultGraph = {:subjects => {}, :listMap => {}, :name => ''}
+      defaultGraph = {:nodes => {}, :listMap => {}, :name => ''}
       graphs = {'' => defaultGraph}
 
       value = nil
       ec = EvaluationContext.new
 
-      # Create a map for subject to object representation
+      # Create a map for node to object representation
 
       # For each triple in input
       input.each do |statement|
@@ -27,7 +27,7 @@ module JSON::LD
         name = statement.context ? ec.expand_iri(statement.context).to_s : ''
         
         # Create a graph entry as needed
-        graph = graphs[name] ||= {:subjects => {}, :listMap => {}, :name => name}
+        graph = graphs[name] ||= {:nodes => {}, :listMap => {}, :name => name}
         
         case statement.predicate
         when RDF.first
@@ -57,15 +57,15 @@ module JSON::LD
         end
 
         # Add entry to default graph for name unless it is empty
-        defaultGraph[:subjects][name] ||= {'@id' => name} unless name.empty?
+        defaultGraph[:nodes][name] ||= {'@id' => name} unless name.empty?
         
-        # Get value from graph subjects for subject, initializing it to a new subject declaration for subject if it does not exist
-        debug("@id") { "new subject: #{subject}"} unless graph[:subjects].has_key?(subject)
-        value = graph[:subjects][subject] ||= {'@id' => subject}
+        # Get value from graph nodes for subject, initializing it to a new node declaration for subject if it does not exist
+        debug("@id") { "new subject: #{subject}"} unless graph[:nodes].has_key?(subject)
+        value = graph[:nodes][subject] ||= {'@id' => subject}
 
         # If property is http://www.w3.org/1999/02/22-rdf-syntax-ns#type
-        # and the useRdfType option is not true
-        if statement.predicate == RDF.type && !@options[:useRdfType]
+        # and the notType option is not true
+        if statement.predicate == RDF.type && !@options[:notType]
           object = ec.expand_iri(statement.object).to_s
           debug("@type") { object.inspect}
           # append the string representation of object to the array value for the key @type, creating
@@ -78,11 +78,10 @@ module JSON::LD
           key = ec.expand_iri(statement.predicate).to_s
           (value[key] ||= []) << {"@list" => []}
         else
-          # Otherwise, let key be the string representation of predicate and 
-          # let object representation be object represented in expanded form as 
-          # described in Value Expansion.
+          # Otherwise, let key be the string representation of predicate and let object representation
+          # be object represented in expanded form as described in Value Expansion.
           key = ec.expand_iri(statement.predicate).to_s
-          object = ec.expand_value(key, statement.object, @options)
+          object = ec.expand_value(key, statement.object, :native => false)
           if blank_node?(object)
             # if object is an Unnamed Node, set as the head element in the listMap
             # entry for object
@@ -122,15 +121,15 @@ module JSON::LD
 
       # Build graphs in @id order
       debug("graphs") {graphs.to_json(JSON_STATE)}
-      array = defaultGraph[:subjects].keys.sort.map do |subject|
-        entry = defaultGraph[:subjects][subject]
+      array = defaultGraph[:nodes].keys.sort.map do |subject|
+        entry = defaultGraph[:nodes][subject]
         debug("=> default") {entry.to_json(JSON_STATE)}
         
         # If subject is a named graph, add serialized subject defintions
         if graphs.has_key?(subject) && !subject.empty?
-          entry['@graph'] = graphs[subject][:subjects].keys.sort.map do |s|
+          entry['@graph'] = graphs[subject][:nodes].keys.sort.map do |s|
             debug("=> #{s.inspect}")
-            graphs[subject][:subjects][s]
+            graphs[subject][:nodes][s]
           end
         end
         

data/lib/json/ld/utils.rb

@@ -1,23 +1,23 @@
 module JSON::LD
   module Utils
     ##
-    # Is value a subject? A value is a subject if
+    # Is value a node? A value is a node if
     # * it is a Hash
     # * it is not a @value, @set or @list
     # * it has more than 1 key or any key is not @id
     # @param [Object] value
     # @return [Boolean]
-    def subject?(value)
+    def node?(value)
       value.is_a?(Hash) &&
         (value.keys & %w(@value @list @set)).empty? &&
         !(value.keys - ['@id']).empty?
     end
 
     ##
-    # Is value a subject reference?
+    # Is value a node reference?
     # @param [Object] value
     # @return [Boolean]
-    def subject_reference?(value)
+    def node_reference?(value)
       value.is_a?(Hash) && value.keys == %w(@id)
     end
 
@@ -27,7 +27,7 @@ module JSON::LD
     # @param [Object] value
     # @return [Boolean]
     def blank_node?(value)
-      (subject?(value) || subject_reference?(value)) && value.fetch('@id', '_:')[0,2] == '_:'
+      (node?(value) || node_reference?(value)) && value.fetch('@id', '_:')[0,2] == '_:'
     end
 
     ##

data/spec/compact_spec.rb

@@ -373,7 +373,7 @@ describe JSON::LD::API do
             ]
           }
         },
-        "Uses expanded subject definitions for subject references" => {
+        "Uses expanded node definitions for node references" => {
           :input => [
             {"@id" => "http://example.com/foo"},
             {"@id" => "http://example.com/bar"}

data/spec/evaluation_context_spec.rb

@@ -32,7 +32,7 @@ describe JSON::LD::EvaluationContext do
 
       it "fails given a missing remote @context" do
         RDF::Util::File.stub(:open_file).with("http://example.com/context").and_raise(IOError)
-        lambda {subject.parse("http://example.com/context")}.should raise_error(JSON::LD::InvalidContext, /Failed to retrieve remote context/)
+        lambda {subject.parse("http://example.com/context")}.should raise_error(JSON::LD::InvalidContext, /Failed to parse remote context/)
       end
 
       it "creates mappings" do
@@ -49,18 +49,6 @@ describe JSON::LD::EvaluationContext do
         ec = subject.parse(StringIO.new("{}"))
         ec.mappings.should produce({}, @debug)
       end
-      
-      it "parses a referenced context at a relative URI" do
-        c1 = StringIO.new(%({"@context": "context"}))
-        RDF::Util::File.stub(:open_file).with("http://example.com/c1").and_yield(c1)
-        RDF::Util::File.stub(:open_file).with("http://example.com/context").and_yield(@ctx)
-        ec = subject.parse("http://example.com/c1")
-        ec.mappings.should produce({
-          "name"     => "http://xmlns.com/foaf/0.1/name",
-          "homepage" => "http://xmlns.com/foaf/0.1/homepage",
-          "avatar"   => "http://xmlns.com/foaf/0.1/avatar"
-        }, @debug)
-      end
     end
 
     context "EvaluationContext" do

data/spec/expand_spec.rb

@@ -416,6 +416,74 @@ describe JSON::LD::API do
       end
     end
 
+    context "default vocabulary" do
+      {
+        "property" => {
+          :input => {
+            "@context" => {"@vocab" => "http://example.com/"},
+            "verb" => {"@value" => "foo"}
+          },
+          :output => [{
+            "http://example.com/verb" => [{"@value" => "foo"}]
+          }]
+        },
+        "datatype" => {
+          :input => {
+            "@context" => {"@vocab" => "http://example.com/"},
+            "http://example.org/verb" => {"@value" => "foo", "@type" => "string"}
+          },
+          :output => [
+            "http://example.org/verb" => [{"@value" => "foo", "@type" => "http://example.com/string"}]
+          ]
+        },
+        "expand-0028" => {
+          :input => {
+            "@context" => {
+              "@vocab" => "http://example.org/vocab#",
+              "date" => { "@type" => "dateTime" }
+            },
+            "@id" => "example1",
+            "@type" => "test",
+            "date" => "2011-01-25T00:00:00Z",
+            "embed" => {
+              "@id" => "example2",
+              "expandedDate" => { "@value" => "2012-08-01T00:00:00Z", "@type" => "dateTime" }
+            }
+          },
+          :output => [
+            {
+              "@id" => "http://foo/bar/example1",
+              "@type" => ["http://example.org/vocab#test"],
+              "http://example.org/vocab#date" => [
+                {
+                  "@value" => "2011-01-25T00:00:00Z",
+                  "@type" => "http://example.org/vocab#dateTime"
+                }
+              ],
+              "http://example.org/vocab#embed" => [
+                {
+                  "@id" => "http://foo/bar/example2",
+                  "http://example.org/vocab#expandedDate" => [
+                    {
+                      "@value" => "2012-08-01T00:00:00Z",
+                      "@type" => "http://example.org/vocab#dateTime"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      }.each do |title, params|
+        it title do
+          jld = JSON::LD::API.expand(params[:input], nil, nil,
+            :base => "http://foo/bar/",
+            :debug => @debug)
+          jld.should produce(params[:output], @debug)
+        end
+      end
+    end
+
     context "unmapped properties" do
       {
         "unmapped key" => {

data/spec/flatten_spec.rb

@@ -0,0 +1,180 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+
+describe JSON::LD::API do
+  before(:each) { @debug = []}
+
+  describe "#generate_node_map" do
+    {
+      "single object" => {
+        :input => {"@id" => "http://example.com", "@type" => RDF::RDFS.Resource.to_s},
+        :subjects => %w(http://example.com),
+        :output => {
+          "http://example.com" => {
+            "@id" => "http://example.com", "@type" => [RDF::RDFS.Resource.to_s]
+          }
+        }
+      },
+      "embedded object" => {
+        :input => {
+          "@context" => {"foaf" => RDF::FOAF.to_s},
+          "@id" => "http://greggkellogg.net/foaf",
+          "@type" => ["foaf:PersonalProfile"],
+          "foaf:primaryTopic" => [{
+            "@id" => "http://greggkellogg.net/foaf#me",
+            "@type" => ["foaf:Person"]
+          }]
+        },
+        :subjects => %w(http://greggkellogg.net/foaf http://greggkellogg.net/foaf#me),
+        :output => {
+          "http://greggkellogg.net/foaf" => {
+            "@id" => "http://greggkellogg.net/foaf",
+            "@type" => [RDF::FOAF.PersonalProfile.to_s],
+            RDF::FOAF.primaryTopic.to_s => [{"@id" => "http://greggkellogg.net/foaf#me"}]
+          },
+          "http://greggkellogg.net/foaf#me" => {
+            "@id" => "http://greggkellogg.net/foaf#me",
+            "@type" => [RDF::FOAF.Person.to_s]
+          }
+        }
+      },
+      "embedded anon" => {
+        :input => {
+          "@context" => {"foaf" => RDF::FOAF.to_s},
+          "@id" => "http://greggkellogg.net/foaf",
+          "@type" => "foaf:PersonalProfile",
+          "foaf:primaryTopic" => {
+            "@type" => "foaf:Person"
+          }
+        },
+        :subjects => %w(http://greggkellogg.net/foaf _:t0),
+        :output => {
+          "_:t0" => {
+            "@id" => "_:t0",
+            "@type" => [RDF::FOAF.Person.to_s]
+          },
+          "http://greggkellogg.net/foaf" => {
+            "@id" => "http://greggkellogg.net/foaf",
+            "@type" => [RDF::FOAF.PersonalProfile.to_s],
+            RDF::FOAF.primaryTopic.to_s => [{"@id" => "_:t0"}]
+          },
+        }
+      },
+      "anon in list" => {
+        :input => [{
+          "@id" => "_:a",
+          "http://example.com/list" => [{"@list" => [{"@id" => "_:b"}]}]
+        }, {
+          "@id" => "_:b",
+          "http://example.com/name" => "foo"
+        }],
+        :subjects => %w(_:t0 _:t1),
+        :output => {
+          "_:t0" => {
+            "@id" => "_:t0",
+            "http://example.com/list" => [
+              {
+                "@list" => [
+                  {
+                    "@id" => "_:t1"
+                  }
+                ]
+              }
+            ]
+          },
+          "_:t1" => {
+            "@id" => "_:t1",
+            "http://example.com/name" => [
+              {
+                "@value" => "foo"
+              }
+            ]
+          }
+        }
+      }
+    }.each do |title, params|
+      it title do
+        @debug = []
+        @node_map = Hash.ordered
+        graph = params[:graph] || '@merged'
+        jld = nil
+        JSON::LD::API.new(params[:input], nil, :debug => @debug) do |api|
+          expanded_value = api.expand(api.value, nil, api.context)
+          api.generate_node_map(expanded_value,
+            @node_map,
+            graph,
+            nil,
+            JSON::LD::BlankNodeNamer.new("t"))
+        end
+        @node_map.keys.should produce([graph], @debug)
+        subjects = @node_map[graph]
+        subjects.keys.should produce(params[:subjects], @debug)
+        subjects.should produce(params[:output], @debug)
+      end
+    end
+  end
+
+  describe ".flatten" do
+    {
+      "single object" => {
+        :input => {"@id" => "http://example.com", "@type" => RDF::RDFS.Resource.to_s},
+        :output => [{"@id" => "http://example.com", "@type" => [RDF::RDFS.Resource.to_s]}]
+      },
+      "embedded object" => {
+        :input => {
+          "@context" => {
+            "foaf" => RDF::FOAF.to_s
+          },
+          "@id" => "http://greggkellogg.net/foaf",
+          "@type" => ["foaf:PersonalProfile"],
+          "foaf:primaryTopic" => [{
+            "@id" => "http://greggkellogg.net/foaf#me",
+            "@type" => ["foaf:Person"]
+          }]
+        },
+        :output => [
+          {
+            "@id" => "http://greggkellogg.net/foaf",
+            "@type" => [RDF::FOAF.PersonalProfile.to_s],
+            RDF::FOAF.primaryTopic.to_s => [{"@id" => "http://greggkellogg.net/foaf#me"}]
+          },
+          {
+            "@id" => "http://greggkellogg.net/foaf#me",
+            "@type" => [RDF::FOAF.Person.to_s]
+          }
+        ]
+      },
+      "embedded anon" => {
+        :input => {
+          "@context" => {
+            "foaf" => RDF::FOAF.to_s
+          },
+          "@id" => "http://greggkellogg.net/foaf",
+          "@type" => "foaf:PersonalProfile",
+          "foaf:primaryTopic" => {
+            "@type" => "foaf:Person"
+          }
+        },
+        :output => [
+          {
+            "@id" => "_:t0",
+            "@type" => [RDF::FOAF.Person.to_s]
+          },
+          {
+            "@id" => "http://greggkellogg.net/foaf",
+            "@type" => [RDF::FOAF.PersonalProfile.to_s],
+            RDF::FOAF.primaryTopic.to_s => [{"@id" => "_:t0"}]
+          },
+        ]
+      }
+    }.each do |title, params|
+      it title do
+        @debug = []
+        graph = params[:graph] || '@merged'
+        jld = JSON::LD::API.flatten(params[:input], graph, nil, nil, :debug => @debug) 
+        jld.should produce(params[:output], @debug)
+      end
+    end
+  end
+end

data/spec/frame_spec.rb

@@ -388,154 +388,128 @@ describe JSON::LD::API do
             }
           ]
         }
-      }
-    }.each do |title, params|
-      it title do
-        @debug = []
-        begin
-          jld = JSON::LD::API.frame(params[:input], params[:frame], nil, :debug => @debug)
-          jld.should produce(params[:output], @debug)
-        rescue JSON::LD::ProcessingError, JSON::LD::InvalidContext, JSON::LD::InvalidFrame => e
-          fail("#{e.class}: #{e.message}\n" +
-            "#{@debug.join("\n")}\n" +
-            "Backtrace:\n#{e.backtrace.join("\n")}")
-        end
-      end
-    end
-  end
-  
-  describe "#get_framing_subjects" do
-    {
-      "single object" => {
-        :input => {"@id" => "http://example.com", "@type" => RDF::RDFS.Resource.to_s},
-        :subjects => %w(http://example.com),
-        :output => {
-          "http://example.com" => {
-            "@id" => "http://example.com", "@type" => [RDF::RDFS.Resource.to_s]
-          }
-        }
-      },
-      "embedded object" => {
-        :input => {
-          "@context" => {"foaf" => RDF::FOAF.to_s},
-          "@id" => "http://greggkellogg.net/foaf",
-          "@type" => ["foaf:PersonalProfile"],
-          "foaf:primaryTopic" => [{
-            "@id" => "http://greggkellogg.net/foaf#me",
-            "@type" => ["foaf:Person"]
-          }]
-        },
-        :subjects => %w(http://greggkellogg.net/foaf http://greggkellogg.net/foaf#me),
-        :output => {
-          "http://greggkellogg.net/foaf" => {
-            "@id" => "http://greggkellogg.net/foaf",
-            "@type" => [RDF::FOAF.PersonalProfile.to_s],
-            RDF::FOAF.primaryTopic.to_s => [{"@id" => "http://greggkellogg.net/foaf#me"}]
-          },
-          "http://greggkellogg.net/foaf#me" => {
-            "@id" => "http://greggkellogg.net/foaf#me",
-            "@type" => [RDF::FOAF.Person.to_s]
-          }
-        }
-      },
-      "embedded anon" => {
-        :input => {
-          "@context" => {"foaf" => RDF::FOAF.to_s},
-          "@id" => "http://greggkellogg.net/foaf",
-          "@type" => "foaf:PersonalProfile",
-          "foaf:primaryTopic" => {
-            "@type" => "foaf:Person"
-          }
-        },
-        :subjects => %w(http://greggkellogg.net/foaf _:t0),
-        :output => {
-          "_:t0" => {
-            "@id" => "_:t0",
-            "@type" => [RDF::FOAF.Person.to_s]
-          },
-          "http://greggkellogg.net/foaf" => {
-            "@id" => "http://greggkellogg.net/foaf",
-            "@type" => [RDF::FOAF.PersonalProfile.to_s],
-            RDF::FOAF.primaryTopic.to_s => [{"@id" => "_:t0"}]
-          },
-        }
       },
-    }.each do |title, params|
-      it title do
-        @debug = []
-        @subjects = Hash.ordered
-        jld = nil
-        JSON::LD::API.new(params[:input], nil, :debug => @debug) do |api|
-          expanded_value = api.expand(api.value, nil, api.context)
-          api.get_framing_subjects(@subjects, expanded_value, JSON::LD::BlankNodeNamer.new("t"))
-        end
-        @subjects.keys.should produce(params[:subjects], @debug)
-        @subjects.should produce(params[:output], @debug)
-      end
-    end
-  end
-
-  describe ".flatten" do
-    {
-      "single object" => {
-        :input => {"@id" => "http://example.com", "@type" => RDF::RDFS.Resource.to_s},
-        :output => [{"@id" => "http://example.com", "@type" => [RDF::RDFS.Resource.to_s]}]
-      },
-      "embedded object" => {
-        :input => {
+      "microdata manifest" => {
+        :frame => {
           "@context" => {
-            "foaf" => RDF::FOAF.to_s
+            "xsd" => "http://www.w3.org/2001/XMLSchema#",
+            "rdfs" => "http://www.w3.org/2000/01/rdf-schema#",
+            "mf" => "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#",
+            "mq" => "http://www.w3.org/2001/sw/DataAccess/tests/test-query#",
+    
+            "comment" => "rdfs:comment",
+            "entries" => {"@id" => "mf:entries", "@container" => "@list"},
+            "name" => "mf:name",
+            "action" => "mf:action",
+            "data" => {"@id" => "mq:data", "@type" => "@id"},
+            "query" => {"@id" => "mq:query", "@type" => "@id"},
+            "result" => {"@id" => "mf:result", "@type" => "xsd:boolean"}
           },
-          "@id" => "http://greggkellogg.net/foaf",
-          "@type" => ["foaf:PersonalProfile"],
-          "foaf:primaryTopic" => [{
-            "@id" => "http://greggkellogg.net/foaf#me",
-            "@type" => ["foaf:Person"]
+          "@type" => "mf:Manifest",
+          "entries" => [{
+            "@type" => "mf:ManifestEntry",
+            "action" => {
+              "@type" => "mq:QueryTest"
+            }
           }]
         },
-        :output => [
-          {
-            "@id" => "http://greggkellogg.net/foaf",
-            "@type" => [RDF::FOAF.PersonalProfile.to_s],
-            RDF::FOAF.primaryTopic.to_s => [{"@id" => "http://greggkellogg.net/foaf#me"}]
-          },
-          {
-            "@id" => "http://greggkellogg.net/foaf#me",
-            "@type" => [RDF::FOAF.Person.to_s]
-          }
-        ]
-      },
-      "embedded anon" => {
         :input => {
           "@context" => {
-            "foaf" => RDF::FOAF.to_s
+            "md" => "http://www.w3.org/ns/md#",
+            "mf" => "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#",
+            "mq" => "http://www.w3.org/2001/sw/DataAccess/tests/test-query#",
+            "rdfs" => "http://www.w3.org/2000/01/rdf-schema#"
           },
-          "@id" => "http://greggkellogg.net/foaf",
-          "@type" => "foaf:PersonalProfile",
-          "foaf:primaryTopic" => {
-            "@type" => "foaf:Person"
-          }
+          "@graph" => [
+            {
+              "@id" => "_:manifest",
+              "@type" => "mf:Manifest",
+              "mf:entries" => {"@list" => [
+                {"@id" => "_:entry"}
+              ]},
+              "rdfs:comment" => "Positive processor tests"
+            },
+            {
+              "@id" => "_:entry",
+              "@type" => "mf:ManifestEntry",
+              "mf:action" => {"@id" => "_:query"},
+              "mf:name" => "Test 0001",
+              "mf:result" => "true",
+              "rdfs:comment" => "Item with no itemtype and literal itemprop"
+            },
+            {
+              "@id" => "_:query",
+              "@type" => "mq:QueryTest",
+              "mq:data" => {
+                "@id" => "http://www.w3.org/TR/microdata-rdf/tests/0001.html"
+              },
+              "mq:query" => {
+                "@id" => "http://www.w3.org/TR/microdata-rdf/tests/0001.ttl"
+              }
+            }
+          ]
         },
-        :output => [
-          {
-            "@id" => "_:t0",
-            "@type" => [RDF::FOAF.Person.to_s]
-          },
-          {
-            "@id" => "http://greggkellogg.net/foaf",
-            "@type" => [RDF::FOAF.PersonalProfile.to_s],
-            RDF::FOAF.primaryTopic.to_s => [{"@id" => "_:t0"}]
+        :output => {
+          "@context" => {
+            "xsd" => "http://www.w3.org/2001/XMLSchema#",
+            "rdfs" => "http://www.w3.org/2000/01/rdf-schema#",
+            "mf" => "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#",
+            "mq" => "http://www.w3.org/2001/sw/DataAccess/tests/test-query#",
+            "comment" => "rdfs:comment",
+            "entries" => {
+              "@id" => "mf:entries",
+              "@container" => "@list"
+            },
+            "name" => "mf:name",
+            "action" => "mf:action",
+            "data" => {
+              "@id" => "mq:data",
+              "@type" => "@id"
+            },
+            "query" => {
+              "@id" => "mq:query",
+              "@type" => "@id"
+            },
+            "result" => {
+              "@id" => "mf:result",
+              "@type" => "xsd:boolean"
+            }
           },
-        ]
+          "@graph" => [
+            {
+              "@id" => "_:t0",
+              "@type" => "mf:Manifest",
+              "comment" => "Positive processor tests",
+              "entries" => [
+                {
+                  "@id" => "_:t1",
+                  "@type" => "mf:ManifestEntry",
+                  "action" => {
+                    "@id" => "_:t2",
+                    "@type" => "mq:QueryTest",
+                    "data" => "http://www.w3.org/TR/microdata-rdf/tests/0001.html",
+                    "query" => "http://www.w3.org/TR/microdata-rdf/tests/0001.ttl"
+                  },
+                  "comment" => "Item with no itemtype and literal itemprop",
+                  "mf:result" => "true",
+                  "name" => "Test 0001"
+                }
+              ]
+            }
+          ]
+        }
       }
     }.each do |title, params|
       it title do
         @debug = []
-        jld = nil
-        JSON::LD::API.new(params[:input], nil, :debug => @debug) do |api|
-          jld = api.flatten
+        begin
+          jld = JSON::LD::API.frame(params[:input], params[:frame], nil, :debug => @debug)
+          jld.should produce(params[:output], @debug)
+        rescue JSON::LD::ProcessingError, JSON::LD::InvalidContext, JSON::LD::InvalidFrame => e
+          fail("#{e.class}: #{e.message}\n" +
+            "#{@debug.join("\n")}\n" +
+            "Backtrace:\n#{e.backtrace.join("\n")}")
         end
-        jld.should produce(params[:output], @debug)
       end
     end
   end