json-ld 0.9.1 → 1.0.0

data/{README.markdown → README.md}

@@ -1,8 +1,10 @@
 # JSON-LD reader/writer
 
-[![Build Status](https://secure.travis-ci.org/gkellogg/json-ld.png?branch=master)](http://travis-ci.org/gkellogg/json-ld)
 [JSON-LD][] reader/writer for [RDF.rb][RDF.rb] and fully conforming [JSON-LD][] processor.
 
+[![Gem Version](https://badge.fury.io/rb/json-ld.png)](http://badge.fury.io/rb/json-ld)
+[![Build Status](https://secure.travis-ci.org/gkellogg/json-ld.png?branch=master)](http://travis-ci.org/gkellogg/json-ld)
+
 ## Features
 
 JSON::LD parses and serializes [JSON-LD][] into [RDF][] and implements expansion, compaction and framing API interfaces.
@@ -206,11 +208,20 @@ Install with `gem install json-ld`
 ## Documentation
 Full documentation available on [RubyDoc](http://rubydoc.info/gems/json-ld/file/README.markdown)
 
+## Differences from [JSON-LD API][]
+The specified JSON-LD API is based on a WebIDL definition intended for use within the browser.
+This version implements a more Ruby-like variation of this API without the use
+of futures and callback arguments, preferring Ruby blocks. All API methods
+execute synchronously, so that the return from a method can be used as well as a block.
+
+Note, the API method signatures differed in versions before 1.0, in that they also had
+a callback parameter.
+
 ### Principal Classes
 * {JSON::LD}
   * {JSON::LD::API}
   * {JSON::LD::Compact}
-  * {JSON::LD::EvaluationContext}
+  * {JSON::LD::Context}
   * {JSON::LD::Format}
   * {JSON::LD::Frame}
   * {JSON::LD::FromRDF}
@@ -219,7 +230,7 @@ Full documentation available on [RubyDoc](http://rubydoc.info/gems/json-ld/file/
   * {JSON::LD::Writer}
 
 ## Dependencies
-* [Ruby](http://ruby-lang.org/) (>= 1.8.7) or (>= 1.8.1 with [Backports][])
+* [Ruby](http://ruby-lang.org/) (>= 1.9.2)
 * [RDF.rb](http://rubygems.org/gems/rdf) (>= 1.0)
 * [JSON](https://rubygems.org/gems/json) (>= 1.5)
 
@@ -267,3 +278,4 @@ see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [RDF.rb]:           http://rubygems.org/gems/rdf
 [Backports]:        http://rubygems.org/gems/backports
 [JSON-LD]:          http://json-ld.org/spec/latest/
+[JSON-LD API]:      http://json-ld.org/spec/latest/json-ld-api/

data/VERSION

@@ -1 +1 @@
-0.9.1
+1.0.0

data/lib/json/ld.rb

@@ -26,7 +26,7 @@ module JSON
     require 'json/ld/format'
     require 'json/ld/utils'
     autoload :API,                'json/ld/api'
-    autoload :EvaluationContext,  'json/ld/evaluation_context'
+    autoload :Context,  'json/ld/context'
     autoload :Normalize,          'json/ld/normalize'
     autoload :Reader,             'json/ld/reader'
     autoload :Resource,           'json/ld/resource'
@@ -40,11 +40,20 @@ module JSON
     }.freeze
 
     KEYWORDS = %w(
+      @base
       @container
       @context
+      @default
+      @embed
+      @embedChildren
+      @explicit
       @id
+      @index
+      @graph
       @language
       @list
+      @omitDefault
+      @reverse
       @set
       @type
       @value
@@ -80,98 +89,52 @@ module JSON
     def self.debug=(value); @debug = value; end
     
     class ProcessingError < Exception
-      # The compaction would lead to a loss of information, such as a @language value.
-      LOSSY_COMPACTION = 1
-
-      # The target datatype specified in the coercion rule and the datatype for the typed literal do not match.
-      CONFLICTING_DATATYPES = 2
-      
-      # A list containing another list was detected.
-      LIST_OF_LISTS_DETECTED = 3
-      
-      # When processing a language map, a value not a 
-      ILLEGAL_LANGUAGE_MAP_DETECTED = 4
-      
-      attr_reader :code
-      
-      class Lossy < ProcessingError
-        def initialize(*args)
-          super
-          @code = LOSSY_COMPACTION
-        end
-      end
-
-      class Conflict < ProcessingError
-        def initialize(*args)
-          super
-          @code = CONFLICTING_DATATYPES
-        end
-      end
-
-      class LanguageMap < ProcessingError
-        def initialize(*args)
-          super
-          @code = ILLEGAL_LANGUAGE_MAP_DETECTED
-        end
-      end
-
-      class ListOfLists < ProcessingError
-        def initialize(*args)
-          super
-          @code = LIST_OF_LISTS_DETECTED
-        end
-      end
+      class CompactionToListOfLists < ProcessingError; end
+      class Conflict < ProcessingError; end
+      class ConflictingIndexes < ProcessingError; end
+      class InvalidIdValue < ProcessingError; end
+      class InvalidIndexValue < ProcessingError; end
+      class InvalidLanguageMapValue < ProcessingError; end
+      class InvalidLanguageTaggedString < ProcessingError; end
+      class InvalidLanguageTaggedValue < ProcessingError; end
+      class InvalidReversePropertyMap < ProcessingError; end
+      class InvalidReversePropertyValue < ProcessingError; end
+      class InvalidReverseValue < ProcessingError; end
+      class InvalidSetOrListObject < ProcessingError; end
+      class InvalidTypedValue < ProcessingError; end
+      class InvalidTypeValue < ProcessingError; end
+      class InvalidValueObject < ProcessingError; end
+      class InvalidValueObjectValue < ProcessingError; end
+      class LanguageMap < ProcessingError; end
+      class ListOfLists < ProcessingError; end
+      class LoadingDocumentFailed < ProcessingError; end
+      class Lossy < ProcessingError; end
     end
     
     class InvalidContext < Exception
-      # A general syntax error was detected in the @context. For example, if a @type key maps to anything
-      # other than @id or an absolute IRI, this exception would be raised.
-      INVALID_SYNTAX	= 1
-
-      # There was a problem encountered loading a remote context.
-      LOAD_ERROR = 2
-      
-      attr_reader :code
-      
-      class Syntax < InvalidContext
-        def initialize(*args)
-          super
-          @code = INVALID_SYNTAX
-        end
-      end
-
-      class LoadError < InvalidContext
-        def initialize(*args)
-          super
-          @code = LOAD_ERROR
-        end
-      end
+      class CollidingKeywords < InvalidContext; end
+      class CyclicIRIMapping < InvalidContext; end
+      class InvalidBaseIRI < InvalidContext; end
+      class InvalidBaseIRI < InvalidContext; end
+      class InvalidContainerMapping < InvalidContext; end
+      class InvalidDefaultLanguage < InvalidContext; end
+      class InvalidIRIMapping < InvalidContext; end
+      class InvalidKeywordAlias < InvalidContext; end
+      class InvalidLanguageMapping < InvalidContext; end
+      class InvalidLocalContext < InvalidContext; end
+      class InvalidRemoteContext < InvalidContext; end
+      class InvalidReverseProperty < InvalidContext; end
+      class InvalidTermDefinition < InvalidContext; end
+      class InvalidTypeMapping < InvalidContext; end
+      class InvalidVocabMapping < InvalidContext; end
+      class KeywordRedefinition < InvalidContext; end
+      class LoadingRemoteContextFailed < InvalidContext; end
+      class RecursiveContextInclusion < InvalidContext; end
     end
     
     class InvalidFrame < Exception
-      # A frame must be either an object or an array of objects, if the frame is neither of these types,
-      # this exception is thrown.
-      INVALID_SYNTAX	= 1
-
-      # A subject IRI was specified in more than one place in the input frame.
-      # More than one embed of a given subject IRI is not allowed, and if requested, must result in this exception.
-      MULTIPLE_EMBEDS = 2
-      
-      attr_reader :code
-
-      class Syntax < InvalidFrame
-        def initialize(*args)
-          super
-          @code = INVALID_SYNTAX
-        end
-      end
-
-      class MultipleEmbeds < InvalidFrame
-        def initialize(*args)
-          super
-          @code = MULTIPLE_EMBEDS
-        end
-      end
+      class MultipleEmbeds < InvalidFrame; end
+      class Syntax < InvalidFrame; end
     end
   end
 end

data/lib/json/ld/api.rb

@@ -8,11 +8,11 @@ require 'json/ld/from_rdf'
 
 module JSON::LD
   ##
-  # A JSON-LD processor implementing the JsonLdProcessor interface.
+  # A JSON-LD processor based on the JsonLdProcessor interface.
   #
-  # This API provides a clean mechanism that enables developers to convert JSON-LD data into a a variety of output formats that
-  # are easier to work with in various programming languages. If a JSON-LD API is provided in a programming environment, the
-  # entirety of the following API must be implemented.
+  # This API provides a clean mechanism that enables developers to convert JSON-LD data into a a variety of output formats that are easier to work with in various programming languages. If a JSON-LD API is provided in a programming environment, the entirety of the following API must be implemented.
+  #
+  # Note that the API method signatures are somewhat different than what is specified, as the use of Futures and explicit callback parameters is not as relevant for Ruby-based interfaces.
   #
   # @see http://json-ld.org/spec/latest/json-ld-api/#the-application-programming-interface
   # @author [Gregg Kellogg](http://greggkellogg.net/)
@@ -36,7 +36,7 @@ module JSON::LD
 
     # Input evaluation context
     # @!attribute [rw] context
-    # @return [JSON::LD::EvaluationContext]
+    # @return [JSON::LD::Context]
     attr_accessor :context
 
     # Current Blank Node Namer
@@ -48,15 +48,13 @@ module JSON::LD
     # Initialize the API, reading in any document and setting global options
     #
     # @param [String, #read, Hash, Array] input
-    # @param [String, #read,, Hash, Array, JSON::LD::EvaluationContext] context
+    # @param [String, #read,, Hash, Array, JSON::LD::Context] context
     #   An external context to use additionally to the context embedded in input when expanding the input.
     # @param  [Hash{Symbol => Object}] options
     # @option options [Boolean] :base
     #   The Base IRI to use when expanding the document. This overrides the value of `input` if it is a _IRI_. If not specified and `input` is not an _IRI_, the base IRI defaults to the current document IRI if in a browser context, or the empty string if there is no document context.
     # @option options [Boolean] :compactArrays (true)
     #   If set to `true`, the JSON-LD processor replaces arrays with just one element with that element during compaction. If set to `false`, all arrays will remain arrays even if they have just one element.
-    # @option options [Proc] :conformanceCallback
-    #   The purpose of this option is to instruct the processor about whether or not it should continue processing. If the value is null, the processor should ignore any key-value pair associated with any recoverable conformance issue and continue processing. More details about this feature can be found in the ConformanceCallback section.
     # @option options [Boolean, String, RDF::URI] :flatten
     #   If set to a value that is not `false`, the JSON-LD processor must modify the output of the Compaction Algorithm or the Expansion Algorithm by coalescing all properties associated with each subject via the Flattening Algorithm. The value of `flatten must` be either an _IRI_ value representing the name of the graph to flatten, or `true`. If the value is `true`, then the first graph encountered in the input document is selected and flattened.
     # @option options [Boolean] :optimize (false)
@@ -73,7 +71,7 @@ module JSON::LD
     def initialize(input, context, options = {}, &block)
       @options = {:compactArrays => true}.merge(options)
       options = {:rename_bnodes => true}.merge(options)
-      @namer = options[:rename_bnodes] ? BlankNodeNamer.new("t") : BlankNodeMapper.new
+      @namer = options[:rename_bnodes] ? BlankNodeNamer.new("b") : BlankNodeMapper.new
       @value = case input
       when Array, Hash then input.dup
       when IO, StringIO then JSON.parse(input.read)
@@ -83,7 +81,7 @@ module JSON::LD
         RDF::Util::File.open_file(input, OPEN_OPTS) {|f| content = JSON.parse(f.read)}
         content
       end
-      @context = EvaluationContext.new(@options)
+      @context = Context.new(@options)
       @context = @context.parse(context) if context
       
       if block_given?
@@ -98,16 +96,12 @@ module JSON::LD
     # Expands the given input according to the steps in the Expansion Algorithm. The input must be copied, expanded and returned
     # if there are no errors. If the expansion fails, an appropriate exception must be thrown.
     #
-    # The resulting `Array` is returned via the provided callback.
-    #
-    # Note that for Ruby, if the callback is not provided and a block is given, it will be yielded
+    # The resulting `Array` either returned or yielded
     #
     # @param [String, #read, Hash, Array] input
     #   The JSON-LD object to copy and perform the expansion upon.
-    # @param [String, #read, Hash, Array, JSON::LD::EvaluationContext] context
+    # @param [String, #read, Hash, Array, JSON::LD::Context] context
     #   An external context to use additionally to the context embedded in input when expanding the input.
-    # @param [Proc] callback (&block)
-    #   Alternative to using block, with same parameters.
     # @param  [Hash{Symbol => Object}] options
     #   See options in {JSON::LD::API#initialize}
     # @raise [InvalidContext]
@@ -117,7 +111,7 @@ module JSON::LD
     # @return [Array<Hash>]
     #   The expanded JSON-LD document
     # @see http://json-ld.org/spec/latest/json-ld-api/#expansion-algorithm
-    def self.expand(input, context = nil, callback = nil, options = {})
+    def self.expand(input, context = nil, options = {})
       result = nil
       API.new(input, context, options) do |api|
         result = api.expand(api.value, nil, api.context)
@@ -129,7 +123,6 @@ module JSON::LD
 
       # Finally, if element is a JSON object, it is wrapped into an array.
       result = [result].compact unless result.is_a?(Array)
-      callback.call(result) if callback
       yield result if block_given?
       result
     end
@@ -140,16 +133,12 @@ module JSON::LD
     #
     # If no context is provided, the input document is compacted using the top-level context of the document
     #
-    # The resulting `Hash` is returned via the provided callback.
-    #
-    # Note that for Ruby, if the callback is not provided and a block is given, it will be yielded
+    # The resulting `Hash` is either returned or yielded, if a block is given.
     #
     # @param [String, #read, Hash, Array] input
     #   The JSON-LD object to copy and perform the compaction upon.
-    # @param [String, #read, Hash, Array, JSON::LD::EvaluationContext] context
+    # @param [String, #read, Hash, Array, JSON::LD::Context] context
     #   The base context to use when compacting the input.
-    # @param [Proc] callback (&block)
-    #   Alternative to using block, with same parameters.
     # @param  [Hash{Symbol => Object}] options
     #   See options in {JSON::LD::API#initialize}
     #   Other options passed to {JSON::LD::API.expand}
@@ -160,48 +149,38 @@ module JSON::LD
     #   The compacted JSON-LD document
     # @raise [InvalidContext, ProcessingError]
     # @see http://json-ld.org/spec/latest/json-ld-api/#compaction-algorithm
-    def self.compact(input, context, callback = nil, options = {})
+    def self.compact(input, context, options = {})
       expanded = result = nil
 
       # 1) Perform the Expansion Algorithm on the JSON-LD input.
       #    This removes any existing context to allow the given context to be cleanly applied.
-      expanded = API.expand(input, nil, nil, options.merge(:debug => nil))
+      expanded = API.expand(input, nil, options.merge(:debug => nil))
 
       API.new(expanded, context, options) do
         debug(".compact") {"expanded input: #{expanded.to_json(JSON_STATE)}"}
         result = compact(value, nil)
 
         # xxx) Add the given context to the output
-        result = case result
-        when Hash then self.context.serialize.merge(result)
-        when Array
-          kwgraph = self.context.compact_iri('@graph', :quiet => true)
-          self.context.serialize.merge(kwgraph => result)
-        when String
-          kwid = self.context.compact_iri('@id', :quiet => true)
-          self.context.serialize.merge(kwid => result)
+        ctx = self.context.serialize
+        if result.is_a?(Array)
+          kwgraph = self.context.compact_iri('@graph', :vocab => true, :quiet => true)
+          result = result.empty? ? {} : {kwgraph => result}
         end
+        result = ctx.merge(result) unless ctx.empty?
       end
-      callback.call(result) if callback
       yield result if block_given?
       result
     end
 
     ##
-    # Flattens the given input according to the steps in the Flattening Algorithm. The input must be flattened and returned if there are no errors. If the flattening fails, an appropriate exception must be thrown.
-    #
-    # The resulting `Array` is returned via the provided callback.
+    # This algorithm flattens an expanded JSON-LD document by collecting all properties of a node in a single JSON object and labeling all blank nodes with blank node identifiers. This resulting uniform shape of the document, may drastically simplify the code required to process JSON-LD data in certain applications.
     #
-    # Note that for Ruby, if the callback is not provided and a block is given, it will be yielded. If there is no block, the value will be returned.
+    # The resulting `Array` is either returned, or yielded if a block is given.
     #
     # @param [String, #read, Hash, Array] input
     #   The JSON-LD object or array of JSON-LD objects to flatten or an IRI referencing the JSON-LD document to flatten.
-    # @param [String, RDF::URI] graph
-    #   The graph in the document that should be flattened. To return the default graph @default has to be passed, for the merged graph @merged and for any other graph the IRI identifying the graph has to be passed. The default value is @merged.
     # @param [String, #read, Hash, Array, JSON::LD::EvaluationContext] context
     #   An optional external context to use additionally to the context embedded in input when expanding the input.
-    # @param [Proc] callback (&block)
-    #   Alternative to using block, with same parameters.
     # @param  [Hash{Symbol => Object}] options
     #   See options in {JSON::LD::API#initialize}
     #   Other options passed to {JSON::LD::API.expand}
@@ -212,38 +191,45 @@ module JSON::LD
     #   The framed JSON-LD document
     # @raise [InvalidFrame]
     # @see http://json-ld.org/spec/latest/json-ld-api/#framing-algorithm
-    def self.flatten(input, graph, context, callback = nil, options = {})
-      result = nil
-      graph ||= '@merged'
+    def self.flatten(input, context, options = {})
+      flattened = []
 
       # Expand input to simplify processing
-      expanded_input = API.expand(input)
+      expanded_input = API.expand(input, nil, options)
 
       # Initialize input using frame as context
       API.new(expanded_input, nil, options) do
         debug(".flatten") {"expanded input: #{value.to_json(JSON_STATE)}"}
 
-        # Generate _nodeMap_
+        # Initialize node map to a JSON object consisting of a single member whose key is @default and whose value is an empty JSON object.
         node_map = Hash.ordered
-        self.generate_node_map(value, node_map, (graph.to_s == '@merged' ? '@merged' : '@default'))
-        
-        result = []
+        node_map['@default'] = Hash.ordered
+        self.generate_node_map(value, node_map)
 
-        # If nodeMap has no property graph, return result, otherwise set definitions to its value.
-        definitions = node_map.fetch(graph.to_s, {})
-        
-        # Foreach property and value of definitions
-        definitions.keys.sort.each do |prop|
-          value = definitions[prop]
-          result << value
+        default_graph = node_map['@default']
+        node_map.keys.kw_sort.reject {|k| k == '@default'}.each do |graph_name|
+          graph = node_map[graph_name]
+          entry = default_graph[graph_name] ||= {'@id' => graph_name}
+          nodes = entry['@graph'] ||= []
+          graph.keys.kw_sort.each do |id|
+            nodes << graph[id]
+          end
+        end
+        default_graph.keys.kw_sort.each do |id|
+          flattened << default_graph[id]
+        end
+
+        if context && !flattened.empty?
+          # Otherwise, return the result of compacting flattened according the Compaction algorithm passing context ensuring that the compaction result uses the @graph keyword (or its alias) at the top-level, even if the context is empty or if there is only one element to put in the @graph array. This ensures that the returned document has a deterministic structure.
+          compacted = compact(flattened, nil)
+          compacted = [compacted] unless compacted.is_a?(Array)
+          kwgraph = self.context.compact_iri('@graph', :quiet => true)
+          flattened = self.context.serialize.merge(kwgraph => compacted)
         end
-        
-        result
       end
 
-      callback.call(result) if callback
-      yield result if block_given?
-      result
+      yield flattened if block_given?
+      flattened
     end
 
     ##
@@ -251,16 +237,12 @@ module JSON::LD
     # framed output and is returned if there are no errors. If there are no matches for the frame, null must be returned.
     # Exceptions must be thrown if there are errors.
     #
-    # The resulting `Array` is returned via the provided callback.
-    #
-    # Note that for Ruby, if the callback is not provided and a block is given, it will be yielded
+    # The resulting `Array` is either returned, or yielded if a block is given.
     #
     # @param [String, #read, Hash, Array] input
     #   The JSON-LD object to copy and perform the framing on.
     # @param [String, #read, Hash, Array] frame
     #   The frame to use when re-arranging the data.
-    # @param [Proc] callback (&block)
-    #   Alternative to using block, with same parameters.
     # @param  [Hash{Symbol => Object}] options
     #   See options in {JSON::LD::API#initialize}
     #   Other options passed to {JSON::LD::API.expand}
@@ -280,7 +262,7 @@ module JSON::LD
     #   The framed JSON-LD document
     # @raise [InvalidFrame]
     # @see http://json-ld.org/spec/latest/json-ld-api/#framing-algorithm
-    def self.frame(input, frame, callback = nil, options = {})
+    def self.frame(input, frame, options = {})
       result = nil
       match_limit = 0
       framing_state = {
@@ -312,19 +294,22 @@ module JSON::LD
       # Initialize input using frame as context
       API.new(expanded_input, nil, options) do
         #debug(".frame") {"context from frame: #{context.inspect}"}
-        #debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE)}"}
-        #debug(".frame") {"expanded input: #{value.to_json(JSON_STATE)}"}
+        debug(".frame") {"raw frame: #{frame.to_json(JSON_STATE)}"}
+        debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE)}"}
+        debug(".frame") {"expanded input: #{value.to_json(JSON_STATE)}"}
 
         # Get framing nodes from expanded input, replacing Blank Node identifiers as necessary
         all_nodes = Hash.ordered
+        old_dbg, @options[:debug] = @options[:debug], nil
         depth do
           generate_node_map(value, all_nodes, '@merged')
         end
+        @options[:debug] = old_dbg
         @node_map = all_nodes['@merged']
         debug(".frame") {"node_map: #{@node_map.to_json(JSON_STATE)}"}
 
         result = []
-        frame(framing_state, @node_map, expanded_frame[0], result, nil)
+        frame(framing_state, @node_map, (expanded_frame.first || {}), result, nil)
         debug(".frame") {"after frame: #{result.to_json(JSON_STATE)}"}
         
         # Initalize context from frame
@@ -340,7 +325,6 @@ module JSON::LD
         result = cleanup_preserve(result)
       end
 
-      callback.call(result) if callback
       yield result if block_given?
       result
     end
@@ -348,14 +332,10 @@ module JSON::LD
     ##
     # Processes the input according to the RDF Conversion Algorithm, calling the provided callback for each triple generated.
     #
-    # Note that for Ruby, if the callback is not provided and a block is given, it will be yielded
-    #
     # @param [String, #read, Hash, Array] input
     #   The JSON-LD object to process when outputting statements.
-    # @param [String, #read, Hash, Array, JSON::LD::EvaluationContext] context
+    # @param [String, #read, Hash, Array, JSON::LD::Context] context
     #   An external context to use additionally to the context embedded in input when expanding the input.
-    # @param [Proc] callback (&block)
-    #   Alternative to using block, with same parameteres.
     # @param [{Symbol,String => Object}] options
     #   See options in {JSON::LD::API#initialize}
     #   Options passed to {JSON::LD::API.expand}
@@ -363,21 +343,35 @@ module JSON::LD
     # @return [Array<RDF::Statement>] if no block given
     # @yield statement
     # @yieldparam [RDF::Statement] statement
-    def self.toRDF(input, context = nil, callback = nil, options = {}, &block)
+    def self.toRDF(input, context = nil, options = {}, &block)
       results = []
-      API.new(input, context, options) do |api|
+      results.extend(RDF::Enumerable)
+
+      # Expand input to simplify processing
+      expanded_input = API.expand(input, context, options)
+
+      API.new(expanded_input, context, options) do
         # 1) Perform the Expansion Algorithm on the JSON-LD input.
         #    This removes any existing context to allow the given context to be cleanly applied.
-        result = api.expand(api.value, nil, api.context)
+        debug(".toRDF") {"expanded input: #{expanded_input.to_json(JSON_STATE)}"}
+
+        # Generate _nodeMap_
+        node_map = Hash.ordered
+        node_map['@default'] = Hash.ordered
+        generate_node_map(expanded_input, node_map)
+        debug(".toRDF") {"node map: #{node_map.to_json(JSON_STATE)}"}
 
-        api.send(:debug, ".expand") {"expanded input: #{result.to_json(JSON_STATE)}"}
         # Start generating statements
-        api.statements("", result, nil, nil, nil) do |statement|
-          callback ||= block if block_given?
-          if callback
-            callback.call(statement)
-          else
-            results << statement
+        node_map.each do |graph_name, graph|
+          context = as_resource(graph_name) unless graph_name == '@default'
+          debug(".toRDF") {"context: #{context ? context.to_ntriples : 'null'}"}
+          graph_to_rdf(graph).each do |statement|
+            statement.context = context if context
+            if block_given?
+              yield statement
+            else
+              results << statement
+            end
           end
         end
       end
@@ -387,13 +381,9 @@ module JSON::LD
     ##
     # Take an ordered list of RDF::Statements and turn them into a JSON-LD document.
     #
-    # The resulting `Array` is returned via the provided callback.
-    #
-    # Note that for Ruby, if the callback is not provided and a block is given, it will be yielded
+    # The resulting `Array` is either returned or yielded, if a block is given.
     #
     # @param [Array<RDF::Statement>] input
-    # @param [Proc] callback (&block)
-    #   Alternative to using block, with same parameteres.
     # @param  [Hash{Symbol => Object}] options
     #   See options in {JSON::LD::API#initialize}
     # @yield jsonld
@@ -401,7 +391,7 @@ module JSON::LD
     #   The JSON-LD document in expanded form
     # @return [Array<Hash>]
     #   The JSON-LD document in expanded form
-    def self.fromRDF(input, callback = nil, options = {}, &block)
+    def self.fromRDF(input, options = {}, &block)
       options = {:useNativeTypes => true}.merge(options)
       result = nil
 
@@ -409,8 +399,7 @@ module JSON::LD
         result = api.from_statements(input)
       end
 
-      callback ||= block if block_given?
-      callback.call(result) if callback
+      yield result if block_given?
       result
     end
   end