json-ld 0.0.7 → 0.0.8

data/README

@@ -24,7 +24,7 @@ Full documentation available on [RubyDoc](http://rubydoc.info/gems/json-ld/0.0.4
 
 ##Dependencies
 * [Ruby](http://ruby-lang.org/) (>= 1.8.7) or (>= 1.8.1 with [Backports][])
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.3)
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.4)
 * [JSON](https://rubygems.org/gems/json) (>= 1.5.1)
 
 ## Installation

data/VERSION

@@ -1 +1 @@
-0.0.7
+0.0.8

data/lib/json/ld.rb

@@ -23,35 +23,24 @@ module JSON
     require 'json'
     require 'json/ld/extensions'
     require 'json/ld/format'
-    autoload :Reader,  'json/ld/reader'
-    autoload :VERSION, 'json/ld/version'
-    autoload :Writer,  'json/ld/writer'
-    
-    # Keywords
-    BASE     = '@base'.freeze
-    COERCE   = '@coerce'.freeze
-    CONTEXT  = '@context'.freeze
-    DATATYPE = '@datatype'.freeze
-    IRI      = '@iri'.freeze
-    LANGUAGE = '@language'.freeze
-    LITERAL  = '@literal'.freeze
-    SUBJECT  = '@subject'.freeze
-    TYPE     = '@type'.freeze
-    VOCAB    = '@vocab'.freeze
+    autoload :Normalize,  'json/ld/normalize'
+    autoload :Reader,     'json/ld/reader'
+    autoload :VERSION,    'json/ld/version'
+    autoload :Writer,     'json/ld/writer'
     
     # Default context
     # @see http://json-ld.org/spec/ED/20110507/#the-default-context
     DEFAULT_CONTEXT = {
       '@coerce'       => {
-        IRI  => [TYPE]
+      '@iri'          => ['@type']
       }
     }.freeze
 
     # Default type coercion, in property => datatype order
     DEFAULT_COERCE = {
-      TYPE            => IRI,
+      '@type'            => '@iri',
       RDF.first.to_s  => false,            # Make sure @coerce isn't generated for this
-      RDF.rest.to_s   => IRI,
+      RDF.rest.to_s   => '@iri',
     }.freeze
 
     def self.debug?; @debug; end

data/lib/json/ld/format.rb

@@ -21,13 +21,32 @@ module JSON::LD
   #
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
   class Format < RDF::Format
-    content_type     'application/ld+json',    :extension => :json
-    content_type     'application/ld+json',    :extension => :ld
-    content_type     'application/x-ld+json'
+    content_type     'application/ld+json',
+                     :extensions => [:jsonld, :json, :ld],
+                     :alias => 'application/x-ld+json'
     content_encoding 'utf-8'
 
     reader { JSON::LD::Reader }
     writer { JSON::LD::Writer }
+
+    ##
+    # Sample detection to see if it matches JSON-LD
+    #
+    # Use a text sample to detect the format of an input file. Sub-classes implement
+    # a matcher sufficient to detect probably format matches, including disambiguating
+    # between other similar formats.
+    #
+    # @param [String] sample Beginning several bytes (~ 1K) of input.
+    # @return [Boolean]
+    def self.detect(sample)
+      !!sample.match(/\{\s*"@(subject|context|type|iri)"/m)
+    end
+    
+    ##
+    # Override normal symbol generation
+    def self.to_sym
+      :jsonld
+    end
   end
   
   # Alias for JSON-LD format
@@ -39,7 +58,6 @@ module JSON::LD
   #     RDF::Format.for(:jsonld).reader  #=> JSON::LD::Reader
   #     RDF::Format.for(:jsonld).writer  #=> JSON::LD::Writer
   class JSONLD < RDF::Format
-    content_type     'application/ld+json',    :extension => :jsonld
     content_encoding 'utf-8'
 
     reader { JSON::LD::Reader }

data/lib/json/ld/normalize.rb

@@ -0,0 +1,120 @@
+module JSON::LD
+  ##
+  # Normalize Nodes in a graph. Uses [Normalization Algorithm](http://json-ld.org/spec/latest/#normalization-1)
+  # from [JSON-LD specification](http://json-ld.org/spec/latest/).
+  #
+  # This module takes a graph and returns a new graph, with BNode names normalized to allow
+  # for a canonical ordering of all statements within a graph.
+  #
+  # @example Normalize a graph
+  #   JSON::LD::normalize(graph) => graph
+  #
+  # @see http://json-ld.org/spec/latest
+  # @see http://json-ld.org/spec/latest/#normalization-1
+  # @author [Gregg Kellogg](http://greggkellogg.net/)
+  class Normalize
+    ##
+    # Create a new normalization instance
+    # @param [RDF::Enumerable] graph
+    def initialize(graph)
+      @graph = graph
+    end
+    
+    ##
+    # Perform normalization, and return a new graph with node identifiers normalized
+    # @return [RDF::Graph]
+    def normalize
+      # Create an empty list of expanded nodes and recursively process every object in the expanded input that is not an
+      # expanded IRI, typed literal or language literal
+      nodes = graph.subjects.select {|s| s.node?}
+      
+      forward_mapping = {}
+      reverse_mapping = {}
+      @node_properties = {}
+      graph.each_statment do |st|
+        # Create a forward mapping that relates graph nodes to the IRIs of the targets nodes that they reference. For example,
+        # if a node alpha refers to a node beta via a property, the key in the forward mapping is the subject IRI of alpha and
+        # the value is an array containing at least the subject IRI of beta.
+        if st.subject.node? && st.object.uri?
+          forward_mapping[st.subject] ||= {}
+          forward_mapping[st.subject] << st.object
+        end
+
+        # Create a reverse mapping that relates graph nodes to every other node that refers to them in the graph. For example,
+        # if a node alpha refers to a node beta via a property, the key in the reverse mapping is the subject IRI for beta and
+        # the value is an array containing at least the IRI for alpha.
+        if st.object.node? && st.subject.uri?
+          reverse_mapping[st.object] ||= {}
+          reverse_mapping[st.object] << st.subject
+        end
+        
+        # For node comparisons, keep track of properties of each node
+        if st.subject.node?
+          @node_properties[st.subject] ||= {}
+          @node_properties[st.subject][st.predicate] ||= []
+          @node_properties[st.subject][st.predicate] << st.object
+        end
+      end
+      
+      # Label every unlabeled node according to the Label Generation Algorithm in descending order using the Deep
+      # Comparison Algorithm to determine the sort order.
+      node_mapping = {}
+      gen = "c14n_1"
+      nodes.sort {|a, b| deep_comparison(a) <=> deep_comparison(b) }.each do |node|
+        # name with Label Generation Algorithm and create mapping from original node to new name
+        node_mapping[node] = RDF::Node.new(gen)
+        gen = gen.succ
+      end
+
+      # Add statements to new graph using new node names
+      graph = RDF::Graph.new
+      
+      @graph.each_statement do |st|
+        if st.subject.node? || st.object.node?
+          st = st.dup
+          st.subject = node_mapping.fetch(st.subject, st.subject)
+          st.object = node_mapping.fetch(st.object, st.object)
+        end
+        graph << st
+      end
+      
+      # Return new graph
+      graph
+    end
+    
+    private
+    def shallow_comparison(a, b)
+      # 1. Compare the total number of node properties. The node with fewer properties is first.
+      prop_count_a = @node_properties[a].keys.length
+      prop_count_b = @node_properties[b].keys.length
+      return prop_count_a <=> prop_count_b unless prop_count_a == prop_count_b
+      
+      # 2. Lexicographically sort the property IRIs for each node and compare the sorted lists. If an IRI is found to be
+      # lexicographically smaller, the node containing that IRI is first.
+      p_iri_a = @node_properties[a].keys.map(&:to_s).sort.first
+      p_iri_b = @node_properties[a].keys.map(&:to_s).sort.first
+      return p_iri_a <=> p_iri_b unless p_iri_a == p_iri_b
+
+      # 3. Compare the property values against one another:
+      @node_properties
+      alpha_list
+    end
+    
+    def deep_comparison(a, b)
+      comp = shallow_comparison(a, b)
+      if comp == 0
+      end
+      comp
+    end
+  end
+  
+  ##
+  # Normalize a graph, returning a new graph with node names normalized
+  def normalize(graph)
+    norm = Normalize.new
+    norm.normalize
+  end
+  module_meathod :normalize
+  
+end
+

data/lib/json/ld/reader.rb

@@ -38,7 +38,7 @@ module JSON::LD
 
       # A list of current, in-scope URI mappings.
       #
-      # @attr [Hash{Symbol => String}]
+      # @attr [Hash{String => String}]
       attr :mappings, true
 
       # The default vocabulary
@@ -60,8 +60,15 @@ module JSON::LD
       #
       # As the value may be an array, this is maintained as a reverse mapping of `property` => `type`.
       #
-      # @attr [Hash{RDF::URI => RDF::URI}]
-      attr :coerce, true
+      # @attr [Hash{String => String}]
+      attr :coerce
+
+      # List coercion
+      #
+      # The @list keyword is used to specify that properties having an array value are to be treated
+      # as an ordered list, rather than a normal unordered list
+      # @attr [Array<String>]
+      attr :list
 
       ##
       # Create new evaluation context
@@ -73,6 +80,7 @@ module JSON::LD
         @mappings =  {}
         @vocab = nil
         @coerce = {}
+        @list = []
         yield(self) if block_given?
       end
 
@@ -80,6 +88,7 @@ module JSON::LD
         v = %w([EvaluationContext) + %w(base vocab).map {|a| "#{a}='#{self.send(a).inspect}'"}
         v << "mappings[#{mappings.keys.length}]=#{mappings}"
         v << "coerce[#{coerce.keys.length}]=#{coerce}"
+        v << "list[#{list.length}]=#{list}"
         v.join(", ") + "]"
       end
     end
@@ -100,7 +109,8 @@ module JSON::LD
         begin
           @doc = JSON.load(input)
         rescue JSON::ParserError => e
-          raise RDF::ReaderError, "Failed to parse input document: #{e.message}"
+          raise RDF::ReaderError, "Failed to parse input document: #{e.message}" if validate?
+          @doc = JSON.parse("{}")
         end
 
         if block_given?
@@ -119,9 +129,9 @@ module JSON::LD
       @callback = block
 
       # initialize the evaluation context with the appropriate base
-      ec = EvaluationContext.new do |ec|
-        ec.base = @base_uri if @base_uri
-        parse_context(ec, DEFAULT_CONTEXT)
+      ec = EvaluationContext.new do |e|
+        e.base = @base_uri if @base_uri
+        parse_context(e, DEFAULT_CONTEXT)
       end
 
       traverse("", @doc, nil, nil, ec)
@@ -150,7 +160,7 @@ module JSON::LD
     # @param [EvaluationContext] ec
     #   The active context
     def traverse(path, element, subject, property, ec)
-      add_debug(path, "traverse: s=#{subject.inspect}, p=#{property.inspect}, e=#{ec.inspect}")
+      add_debug(path) {"traverse: s=#{subject.inspect}, p=#{property.inspect}, e=#{ec.inspect}"}
       object = nil
 
       case element
@@ -161,119 +171,105 @@ module JSON::LD
         
         # 2.1) If a @context keyword is found, the processor merges each key-value pair in
         # the local context into the active context ...
-        if element[CONTEXT]
+        if element['@context']
           # Merge context
-          ec = parse_context(ec.dup, element[CONTEXT])
+          ec = parse_context(ec.dup, element['@context'])
           prefixes.merge!(ec.mappings)  # Update parsed prefixes
         end
         
         # 2.2) Create a new associative array by mapping the keys from the current associative array ...
         new_element = {}
         element.each do |k, v|
-          k = ec.mappings[k.to_sym] while ec.mappings.has_key?(k.to_sym)
+          k = ec.mappings[k.to_s] while ec.mappings.has_key?(k.to_s)
           new_element[k] = v
         end
         unless element == new_element
-          add_debug(path, "traverse: keys after map: #{new_element.keys.inspect}")
+          add_debug(path) {"traverse: keys after map: #{new_element.keys.inspect}"}
           element = new_element
         end
 
         # Other shortcuts to allow use of this method for terminal associative arrays
-        if element[IRI].is_a?(String)
-          # Return the IRI found from the value
-          object = expand_term(element[IRI], ec.base, ec)
+        if element['@iri'].is_a?(String)
+          # 2.3 Return the IRI found from the value
+          object = expand_term(element['@iri'], ec.base, ec)
           add_triple(path, subject, property, object) if subject && property
           return
-        elsif element[LITERAL]
+        elsif element['@literal']
+          # 2.4
           literal_opts = {}
-          literal_opts[:datatype] = expand_term(element[DATATYPE], ec.vocab.to_s, ec) if element[DATATYPE]
-          literal_opts[:language] = element[LANGUAGE].to_sym if element[LANGUAGE]
-          object = RDF::Literal.new(element[LITERAL], literal_opts)
+          literal_opts[:datatype] = expand_term(element['@datatype'], ec.vocab.to_s, ec) if element['@datatype']
+          literal_opts[:language] = element['@language'].to_sym if element['@language']
+          object = RDF::Literal.new(element['@literal'], literal_opts)
           add_triple(path, subject, property, object) if subject && property
           return
-        end
-        
-        # 2.3) ... Otherwise, if the local context is known perform the following steps:
-        #   2.3.1) If a @ key is found, the processor sets the active subject to the
-        #         value after Object Processing has been performed.
-        if element[SUBJECT].is_a?(String)
-          active_subject = expand_term(element[SUBJECT], ec.base, ec)
-        elsif element[SUBJECT]
-          # Recursively process hash or Array values
-          traverse("#{path}[#{SUBJECT}]", element[SUBJECT], subject, property, ec)
+        elsif element['@list']
+          # 2.4a (Lists)
+          parse_list("#{path}[#{'@list'}]", element['@list'], subject, property, ec)
+          return
+        elsif element['@subject'].is_a?(String)
+          # 2.5 Subject
+          # 2.5.1 Set active object (subject)
+          active_subject = expand_term(element['@subject'], ec.base, ec)
+        elsif element['@subject']
+          # 2.5.2 Recursively process hash or Array values
+          traverse("#{path}[#{'@subject'}]", element['@subject'], subject, property, ec)
         else
-          # 2.3.7) If the end of the associative array is detected, and a active subject
-          # was not discovered, then:
-          #   2.3.7.1) Generate a blank node identifier and set it as the active subject.
+          # 2.6) Generate a blank node identifier and set it as the active subject.
           active_subject = RDF::Node.new
         end
-          
-        # 2.3.1.1) If the inherited subject and inherited property values are
-        # specified, generate a triple using the inherited subject for the
-        # subject, the inherited property for the property, and the active
-        # subject for the object.
-        # 2.3.7.2) Complete any previously incomplete triples by running all substeps of Step 2.2.1.
+
         add_triple(path, subject, property, active_subject) if subject && property
         subject = active_subject
         
         element.each do |key, value|
-          # 2.3.3) If a key that is not @context, @subject, or @type, set the active property by
+          # 2.7) If a key that is not @context, @subject, or @type, set the active property by
           # performing Property Processing on the key.
           property = case key
-          when TYPE then TYPE
-          when /^@/ then nil
+          when '@type' then '@type'
+          when /^@/ then next
           else      expand_term(key, ec.vocab, ec)
           end
 
-          traverse("#{path}[#{key}]", value, subject, property, ec) if property
+          # 2.7.3
+          if ec.list.include?(property.to_s) && value.is_a?(Array)
+            # 2.7.3.1 (Lists) If the active property is the target of a @list coercion, and the value is an array,
+            #         process the value as a list starting at Step 3a.
+            parse_list("#{path}[#{key}]", value, subject, property, ec)
+          else
+            traverse("#{path}[#{key}]", value, subject, property, ec)
+          end
         end
       when Array
         # 3) If a regular array is detected, process each value in the array by doing the following:
         element.each_with_index do |v, i|
-          case v
-          when Hash, String
-            traverse("#{path}[#{i}]", v, subject, property, ec)
-          when Array
-            # 3.3) If the value is a regular array, should we support RDF List/Sequence Processing?
-            last = v.pop
-            first_bnode = last ? RDF::Node.new : RDF.nil            
-            add_triple("#{path}[#{i}][]", subject, property, first_bnode)
-
-            v.each do |list_item|
-              traverse("#{path}[#{i}][]", list_item, first_bnode, RDF.first, ec)
-              rest_bnode = RDF::Node.new
-              add_triple("#{path}[#{i}][]", first_bnode, RDF.rest, rest_bnode)
-              first_bnode = rest_bnode
-            end
-            if last
-              traverse("#{path}[#{i}][]", last, first_bnode, RDF.first, ec)
-              add_triple("#{path}[#{i}][]", first_bnode, RDF.rest, RDF.nil)
-            end
-          end
+          traverse("#{path}[#{i}]", v, subject, property, ec)
         end
       when String
         # Perform coersion of the value, or generate a literal
-        add_debug(path, "traverse(#{element}): coerce?(#{property.inspect}) == #{ec.coerce[property.to_s].inspect}, ec=#{ec.coerce.inspect}")
-        object = if ec.coerce[property.to_s] == IRI
+        add_debug(path) do
+          "traverse(#{element}): coerce?(#{property.inspect}) == #{ec.coerce[property.to_s].inspect}, " +
+          "ec=#{ec.coerce.inspect}"
+        end
+        object = if ec.coerce[property.to_s] == '@iri'
           expand_term(element, ec.base, ec)
         elsif ec.coerce[property.to_s]
           RDF::Literal.new(element, :datatype => ec.coerce[property.to_s])
         else
           RDF::Literal.new(element)
         end
-        property = RDF.type if property == TYPE
+        property = RDF.type if property == '@type'
         add_triple(path, subject, property, object) if subject && property
       when Float
         object = RDF::Literal::Double.new(element)
-        add_debug(path, "traverse(#{element}): native: #{object.inspect}")
+        add_debug(path) {"traverse(#{element}): native: #{object.inspect}"}
         add_triple(path, subject, property, object) if subject && property
       when Fixnum
         object = RDF::Literal.new(element)
-        add_debug(path, "traverse(#{element}): native: #{object.inspect}")
+        add_debug(path) {"traverse(#{element}): native: #{object.inspect}"}
         add_triple(path, subject, property, object) if subject && property
       when TrueClass, FalseClass
         object = RDF::Literal::Boolean.new(element)
-        add_debug(path, "traverse(#{element}): native: #{object.inspect}")
+        add_debug(path) {"traverse(#{element}): native: #{object.inspect}"}
         add_triple(path, subject, property, object) if subject && property
       else
         raise RDF::ReaderError, "Traverse to unknown element: #{element.inspect} of type #{element.class}"
@@ -291,7 +287,7 @@ module JSON::LD
     # @raise [ReaderError] Checks parameter types and raises if they are incorrect if parsing mode is _validate_.
     def add_triple(path, subject, predicate, object)
       statement = RDF::Statement.new(subject, predicate, object)
-      add_debug(path, "statement: #{statement.to_ntriples}")
+      add_debug(path) {"statement: #{statement.to_ntriples}"}
       @callback.call(statement)
     end
 
@@ -299,8 +295,11 @@ module JSON::LD
     # Add debug event to debug array, if specified
     #
     # @param [XML Node, any] node:: XML Node or string for showing context
-    # @param [String] message::
-    def add_debug(node, message)
+    # @param [String] message
+    # @yieldreturn [String] appended to message, to allow for lazy-evaulation of message
+    def add_debug(node, message = "")
+      return unless ::JSON::LD.debug? || @options[:debug]
+      message = message + yield if block_given?
       puts "#{node}: #{message}" if JSON::LD::debug?
       @options[:debug] << "#{node}: #{message}" if @options[:debug].is_a?(Array)
     end
@@ -323,39 +322,77 @@ module JSON::LD
       end
       
       context.each do |key, value|
-        add_debug("parse_context(#{key})", value.inspect)
+        add_debug("parse_context(#{key})") {value.inspect}
         case key
-        when VOCAB then ec.vocab = value
-        when BASE  then ec.base  = uri(value)
-        when COERCE
+        when '@vocab' then ec.vocab = value
+        when '@base'  then ec.base  = uri(value)
+        when '@coerce'
           # Process after prefix mapping
         else
           # Spec confusion: The text indicates to merge each key-value pair into the active context. Is any
           # processing performed on the values. For instance, could a value be a CURIE, or {"@iri": <value>}?
           # Examples indicate that there is no such processing, and each value should be an absolute IRI. The
           # wording makes this unclear.
-          ec.mappings[key.to_sym] = value
+          ec.mappings[key.to_s] = value
         end
       end
       
-      if context[COERCE]
+      if context['@coerce']
         # Spec confusion: doc says to merge each key-value mapping to the local context's @coerce mapping,
         # overwriting duplicate values. In the case where a mapping is indicated to a list of properties
         # (e.g., { "@iri": ["foaf:homepage", "foaf:member"] }, does this overwrite a previous mapping
         # of { "@iri": "foaf:knows" }, or add to it.
-        add_error RDF::ReaderError, "Expected @coerce to reference an associative array" unless context[COERCE].is_a?(Hash)
-        context[COERCE].each do |type, property|
+        add_error RDF::ReaderError, "Expected @coerce to reference an associative array" unless context['@coerce'].is_a?(Hash)
+        context['@coerce'].each do |type, property|
+          add_debug("parse_context: @coerce") {"type=#{type}, prop=#{property}"}
           type_uri = expand_term(type, ec.vocab, ec).to_s
           [property].flatten.compact.each do |prop|
             p = expand_term(prop, ec.vocab, ec).to_s
-            ec.coerce[p] = type_uri
+            if type == '@list'
+              # List is managed separate from types, as it is maintained in normal form.
+              ec.list << p unless ec.list.include?(p)
+            else
+              ec.coerce[p] = type_uri
+            end
           end
         end
       end
 
       ec
     end
-    
+
+    ##
+    # Parse a List
+    #
+    # @param [String] path
+    #   location within JSON hash
+    # @param [Array] list
+    #   The Array to serialize as a list
+    # @param [RDF::URI] subject
+    #   Inherited subject
+    # @param [RDF::URI] property
+    #   Inherited property
+    # @param [EvaluationContext] ec
+    #   The active context
+    def parse_list(path, list, subject, property, ec)
+      add_debug(path) {"list: #{list.inspect}, s=#{subject.inspect}, p=#{property.inspect}, e=#{ec.inspect}"}
+
+      last = list.pop
+      first_bnode = last ? RDF::Node.new : RDF.nil            
+      add_triple("#{path}", subject, property, first_bnode)
+
+      list.each do |list_item|
+        traverse("#{path}", list_item, first_bnode, RDF.first, ec)
+        rest_bnode = RDF::Node.new
+        add_triple("#{path}", first_bnode, RDF.rest, rest_bnode)
+        first_bnode = rest_bnode
+      end
+      if last
+        traverse("#{path}", last, first_bnode, RDF.first, ec)
+        add_triple("#{path}", first_bnode, RDF.rest, RDF.nil)
+      end
+    end
+
     ##
     # Expand a term using the specified context
     #
@@ -367,11 +404,9 @@ module JSON::LD
     # @raise [RDF::ReaderError] if the term cannot be expanded
     # @see http://json-ld.org/spec/ED/20110507/#markup-of-rdf-concepts
     def expand_term(term, base, ec)
-      #add_debug("expand_term", "term=#{term.inspect}, base=#{base.inspect}, ec=#{ec.inspect}")
+      #add_debug("expand_term", {"term=#{term.inspect}, base=#{base.inspect}, ec=#{ec.inspect}"}
       prefix, suffix = term.split(":", 2)
-      prefix = prefix.to_sym if prefix
-      return  if prefix == '_'
-      if prefix == :_
+      if prefix == '_'
         bnode(suffix)
       elsif ec.mappings.has_key?(prefix)
         uri(ec.mappings[prefix] + suffix.to_s)
@@ -392,9 +427,12 @@ module JSON::LD
     end
 
     # Keep track of allocated BNodes
+    #
+    # Don't actually use the name provided, to prevent name alias issues.
+    # @return [RDF::Node]
     def bnode(value = nil)
       @bnode_cache ||= {}
-      @bnode_cache[value.to_s] ||= RDF::Node.new(value)
+      @bnode_cache[value.to_s] ||= RDF::Node.new
     end
   end
 end

data/lib/json/ld/version.rb

@@ -1,4 +1,4 @@
-module RDF::N3::VERSION
+module JSON::LD::VERSION
   VERSION_FILE = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "..", "VERSION")
   MAJOR, MINOR, TINY, EXTRA = File.read(VERSION_FILE).chop.split(".")
 

data/lib/json/ld/writer.rb

@@ -7,7 +7,7 @@ module JSON::LD
   # and then serialize the graph.
   #
   # @example Obtaining a JSON-LD writer class
-  #   RDF::Writer.for(:jsonld)         #=> RDF::N3::Writer
+  #   RDF::Writer.for(:jsonld)         #=> JSON::LD::Writer
   #   RDF::Writer.for("etc/test.json")
   #   RDF::Writer.for(:file_name      => "etc/test.json")
   #   RDF::Writer.for(:file_extension => "json")
@@ -47,7 +47,7 @@ module JSON::LD
   #     end
   #   end
   #
-  # Select the :canonicalize option to output JSON-LD in canonical form
+  # Select the :normalize option to output JSON-LD in canonical form
   #
   # @see http://json-ld.org/spec/ED/20110507/
   # @see http://json-ld.org/spec/ED/20110507/#the-normalization-algorithm
@@ -69,6 +69,10 @@ module JSON::LD
     # @attr [Hash{String => String}]
     attr :coerce, true
 
+    ##
+    # Local implementation of ruby Hash class to allow for ordering in 1.8.x implementations.
+    #
+    # @return [Hash, InsertOrderPreservingHash]
     def self.new_hash
       if RUBY_VERSION < "1.9"
         InsertOrderPreservingHash.new
@@ -99,6 +103,8 @@ module JSON::LD
     #   the encoding to use on the output stream (Ruby 1.9+)
     # @option options [Boolean]  :canonicalize (false)
     #   whether to canonicalize literals when serializing
+    # @option options [Boolean] :normalize (false)
+    #   Output document in [normalized form](http://json-ld.org/spec/latest/#normalization-1)
     # @option options [Hash]     :prefixes     (Hash.new)
     #   the prefix mappings to use (not supported by all writers)
     # @option options [#to_s]    :base_uri     (nil)
@@ -115,7 +121,7 @@ module JSON::LD
     def initialize(output = $stdout, options = {}, &block)
       super do
         @graph = RDF::Graph.new
-        @iri_to_prefix = DEFAULT_CONTEXT.dup.delete_if {|k,v| k == COERCE}.invert
+        @iri_to_prefix = DEFAULT_CONTEXT.dup.delete_if {|k,v| k == '@coerce'}.invert
         @coerce = DEFAULT_COERCE.merge(options[:coerce] || {})
         if block_given?
           case block.arity
@@ -132,7 +138,7 @@ module JSON::LD
     # @param  [Graph] graph
     # @return [void]
     def write_graph(graph)
-      add_debug "Add graph #{graph.inspect}"
+      add_debug {"Add graph #{graph.inspect}"}
       @graph = graph
     end
 
@@ -162,18 +168,18 @@ module JSON::LD
     # @return [void]
     # @see    #write_triple
     def write_epilogue
-      @base_uri = RDF::URI(@options[:base_uri]) if @options[:base_uri] && !@options[:canonicalize]
-      @vocab = @options[:vocab] unless @options[:canonicalize]
+      @base_uri = RDF::URI(@options[:base_uri]) if @options[:base_uri] && !@options[:normalize]
+      @vocab = @options[:vocab] unless @options[:normalize]
       @debug = @options[:debug]
 
       reset
 
-      add_debug "\nserialize: graph: #{@graph.size}"
+      add_debug {"\nserialize: graph: #{@graph.size}"}
 
       preprocess
       
       # Don't generate context for canonical output
-      json_hash = @options[:canonicalize] ? new_hash : start_document
+      json_hash = @options[:normalize] ? new_hash : start_document
 
       elements = []
       order_subjects.each do |subject|
@@ -187,13 +193,13 @@ module JSON::LD
       if elements.length == 1 && elements.first.is_a?(Hash)
         json_hash.merge!(elements.first)
       else
-        json_hash[SUBJECT] = elements
+        json_hash['@subject'] = elements
       end
       
       if @output.is_a?(Hash)
         @output.merge!(json_hash)
       else
-        json_state = if @options[:canonicalize]
+        json_state = if @options[:normalize]
           JSON::State.new(
             :indent       => "",
             :space        => "",
@@ -235,17 +241,17 @@ module JSON::LD
         short == value.to_s ? (get_curie(value) || value.to_s) : short
       when :predicate
         # attempt vocab replacement
-        short = TYPE if value == RDF.type
+        short = '@type' if value == RDF.type
         short ||= value.to_s.sub(@vocab.to_s, "")
         short == value.to_s ? (get_curie(value) || value.to_s) : short
       else
         # Encode like a subject
         iri_range?(options[:property]) ?
           format_uri(value, :position => :subject) :
-          {IRI => format_uri(value, :position => :subject)}
+          {'@iri' => format_uri(value, :position => :subject)}
       end
     
-      add_debug("format_uri(#{options.inspect}, #{value.inspect}) => #{result.inspect}")
+      add_debug {"format_uri(#{options.inspect}, #{value.inspect}) => #{result.inspect}"}
       result
     end
     
@@ -268,11 +274,11 @@ module JSON::LD
     #   Property referencing literal for type coercion
     # @return [Object]
     def format_literal(literal, options = {})
-      if options[:canonical] || @options[:canonicalize]
+      if options[:normal] || @options[:normalize]
         ret = new_hash
-        ret[LITERAL] = literal.value
-        ret[DATATYPE] = format_uri(literal.datatype, :position => :subject)if literal.has_datatype?
-        ret[LANGUAGE] = literal.language.to_s if literal.has_language?
+        ret['@literal'] = literal.value
+        ret['@datatype'] = format_uri(literal.datatype, :position => :subject) if literal.has_datatype?
+        ret['@language'] = literal.language.to_s if literal.has_language?
         return ret.delete_if {|k,v| v.nil?}
       end
 
@@ -284,7 +290,7 @@ module JSON::LD
           # Datatype coercion where literal has the same datatype
           literal.value
         else
-          format_literal(literal, :canonical => true)
+          format_literal(literal, :normal => true)
         end
       end
     end
@@ -295,12 +301,12 @@ module JSON::LD
     # @param  [Hash{Symbol => Object}] options
     # @option options [RDF::URI] property
     #   Property referencing literal for type coercion
-    # @return [Array<Array<Object>>]
+    # @return [Hash{"@list" => Array<Object>}]
     def format_list(object, options = {})
       predicate = options[:property]
       list = []
 
-      add_debug "format_list(#{object}, #{predicate})"
+      add_debug {"format_list(#{object}, #{predicate})"}
 
       @depth += 1
       while object do
@@ -308,7 +314,7 @@ module JSON::LD
         p = @graph.properties(object)
         item = p.fetch(RDF.first.to_s, []).first
         if item
-          add_debug "format_list serialize #{item.inspect}"
+          add_debug {"format_list serialize #{item.inspect}"}
           list << if predicate || item.literal?
             property(predicate, item)
           else
@@ -320,8 +326,8 @@ module JSON::LD
       @depth -= 1
     
       # Returns 
-      add_debug "format_list => #{[list].inspect}"
-      [list]
+      add_debug {"format_list => #{{'@list' => list}.inspect}"}
+      {'@list' => list}
     end
 
     private
@@ -330,26 +336,26 @@ module JSON::LD
     # @return [Hash]
     def start_document
       ctx = new_hash
-      ctx[BASE] = base_uri.to_s if base_uri
-      ctx[VOCAB] = vocab.to_s if vocab
+      ctx['@base'] = base_uri.to_s if base_uri
+      ctx['@vocab'] = vocab.to_s if vocab
       
       # Prefixes
       prefixes.keys.sort {|a,b| a.to_s <=> b.to_s}.each do |k|
         next if DEFAULT_CONTEXT.has_key?(k.to_s)
-        add_debug "prefix[#{k}] => #{prefixes[k]}"
+        add_debug {"prefix[#{k}] => #{prefixes[k]}"}
         ctx[k.to_s] = prefixes[k].to_s
       end
       
       # Coerce
-      add_debug "start_doc: coerce= #{coerce.inspect}"
+      add_debug {"start_doc: coerce= #{coerce.inspect}"}
       unless coerce == DEFAULT_COERCE
         c_h = new_hash
         coerce.keys.sort.each do |k|
-          next if [TYPE, RDF.type.to_s].include?(k.to_s)
+          next if ['@type', RDF.type.to_s].include?(k.to_s)
           next if [DEFAULT_COERCE[k], false, RDF::XSD.integer.to_s, RDF::XSD.boolean.to_s].include?(coerce[k])
-          k_iri = k == IRI ? IRI : format_uri(k, :position => :predicate)
+          k_iri = k == '@iri' ? '@iri' : format_uri(k, :position => :predicate)
           d_iri = format_uri(coerce[k], :position => :subject)
-          add_debug "coerce[#{k_iri}] => #{d_iri}, k=#{k.inspect}"
+          add_debug {"coerce[#{k_iri}] => #{d_iri}, k=#{k.inspect}"}
           case c_h[d_iri]
           when nil
             c_h[d_iri] = k_iri
@@ -360,14 +366,14 @@ module JSON::LD
           end
         end
         
-        ctx[COERCE] = c_h unless c_h.empty?
+        ctx['@coerce'] = c_h unless c_h.empty?
       end
 
-      add_debug "start_doc: context=#{ctx.inspect}"
+      add_debug {"start_doc: context=#{ctx.inspect}"}
 
       # Return hash with @context, or empty
       r = new_hash
-      r[CONTEXT] = ctx unless ctx.empty?
+      r['@context'] = ctx unless ctx.empty?
       r
     end
     
@@ -386,7 +392,7 @@ module JSON::LD
     # prefixes.
     # @param [Statement] statement
     def preprocess_statement(statement)
-      add_debug "preprocess: #{statement.inspect}"
+      add_debug {"preprocess: #{statement.inspect}"}
       references = ref_count(statement.object) + 1
       @references[statement.object] = references
       @subjects[statement.subject] = true
@@ -414,35 +420,35 @@ module JSON::LD
 
       subject_done(subject)
       properties = @graph.properties(subject)
-      add_debug "subject: #{subject.inspect}, props: #{properties.inspect}"
+      add_debug {"subject: #{subject.inspect}, props: #{properties.inspect}"}
 
       @graph.query(:subject => subject).each do |st|
         raise RDF::WriterError, "Illegal use of predicate #{st.predicate.inspect}, not supported in RDF/XML" unless st.predicate.uri?
       end
 
-      if subject.node? && ref_count(subject) > (options[:property] ? 1 : 0) && options[:canonicalize]
+      if subject.node? && ref_count(subject) > (options[:property] ? 1 : 0) && options[:normalize]
         raise RDF::WriterError, "Can't serialize named node when normalizing"
       end
 
       # Subject may be a list
       if is_valid_list?(subject)
         add_debug "subject is a list"
-        defn[SUBJECT] = format_list(subject)
+        defn['@subject'] = format_list(subject)
         properties.delete(RDF.first.to_s)
         properties.delete(RDF.rest.to_s)
         
         # Special case, if there are no properties, then we can just serialize the list itself
-        return defn[SUBJECT].first if properties.empty?
+        return defn if properties.empty?
       elsif subject.uri? || ref_count(subject) > 1
         add_debug "subject is a uri"
         # Don't need to set subject if it's a Node without references
-        defn[SUBJECT] = format_uri(subject, :position => :subject)
+        defn['@subject'] = format_uri(subject, :position => :subject)
       else
         add_debug "subject is an unreferenced BNode"
       end
 
       prop_list = order_properties(properties)
-      #add_debug "=> property order: #{prop_list.to_sentence}"
+      #add_debug {"=> property order: #{prop_list.to_sentence}"}
 
       prop_list.each do |prop|
         predicate = RDF::URI.intern(prop)
@@ -450,11 +456,11 @@ module JSON::LD
         p_iri = format_uri(predicate, :position => :predicate)
         @depth += 1
         defn[p_iri] = property(predicate, properties[prop])
-        add_debug "prop(#{p_iri}) => #{properties[prop]} => #{defn[p_iri].inspect}"
+        add_debug {"prop(#{p_iri}) => #{properties[prop]} => #{defn[p_iri].inspect}"}
         @depth -= 1
       end
       
-      add_debug "subject: #{subject} has defn: #{defn.inspect}"
+      add_debug {"subject: #{subject} has defn: #{defn.inspect}"}
       defn
     end
     
@@ -490,7 +496,7 @@ module JSON::LD
     # @param [RDF::Resource] resource
     # @return [String, nil] value to use to identify IRI
     def get_curie(resource)
-      add_debug "get_curie(#{resource.inspect})"
+      add_debug {"get_curie(#{resource.inspect})"}
       case resource
       when RDF::Node
         return resource.to_s
@@ -500,7 +506,7 @@ module JSON::LD
         return nil unless resource.absolute?
       when RDF::URI
         iri = resource.to_s
-        return iri if options[:canonicalize]
+        return iri if options[:normalize]
       else
         return nil
       end
@@ -555,7 +561,7 @@ module JSON::LD
       
       return @subjects.keys.sort do |a,b|
         format_iri(a, :position => :subject) <=> format_iri(b, :position => :subject)
-      end if @options[:canonicalize]
+      end if @options[:normalize]
 
       # Start with base_uri
       if base_uri && @subjects.keys.include?(base_uri)
@@ -583,16 +589,16 @@ module JSON::LD
     # @param [RDF::URI] predicate
     # @return [Boolean]
     def iri_range?(predicate)
-      return false if predicate.nil? || @options[:canonicalize]
+      return false if predicate.nil? || @options[:normalize]
 
       unless coerce.has_key?(predicate.to_s)
         # objects of all statements with the predicate may not be literal
        coerce[predicate.to_s] = @graph.query(:predicate => predicate).to_a.any? {|st| st.object.literal?} ?
-          false : IRI
+          false : '@iri'
       end
       
-      add_debug "iri_range(#{predicate}) = #{coerce[predicate.to_s].inspect}"
-      coerce[predicate.to_s] == IRI
+      add_debug {"iri_range(#{predicate}) = #{coerce[predicate.to_s].inspect}"}
+      coerce[predicate.to_s] == '@iri'
     end
     
     ##
@@ -612,7 +618,7 @@ module JSON::LD
             dt = false
           end
         end
-        add_debug "range(#{predicate}) = #{dt.inspect}"
+        add_debug {"range(#{predicate}) = #{dt.inspect}"}
         coerce[predicate.to_s] = dt
       end
 
@@ -630,8 +636,11 @@ module JSON::LD
 
     # Add debug event to debug array, if specified
     #
-    # @param [String] message::
-    def add_debug(message)
+    # @param [String] message
+    # @yieldreturn [String] appended to message, to allow for lazy-evaulation of message
+    def add_debug(message = "")
+      return unless ::JSON::LD.debug? || @options[:debug]
+      message = message + yield if block_given?
       msg = "#{" " * @depth * 2}#{message}"
       STDERR.puts msg if ::JSON::LD::debug?
       @debug << msg if @debug.is_a?(Array)
@@ -641,26 +650,26 @@ module JSON::LD
     def is_valid_list?(l)
       props = @graph.properties(l)
       unless l.node? && props.has_key?(RDF.first.to_s) || l == RDF.nil
-        add_debug "is_valid_list: false, #{l.inspect}: #{props.inspect}"
+        add_debug {"is_valid_list: false, #{l.inspect}: #{props.inspect}"}
         return false
       end
 
       while l && l != RDF.nil do
-        #add_debug "is_valid_list(length): #{props.length}"
+        #add_debug {"is_valid_list(length): #{props.length}"}
         return false unless props.has_key?(RDF.first.to_s) && props.has_key?(RDF.rest.to_s)
         n = props[RDF.rest.to_s]
         unless n.is_a?(Array) && n.length == 1
-          add_debug "is_valid_list: false, #{n.inspect}"
+          add_debug {"is_valid_list: false, #{n.inspect}"}
           return false
         end
         l = n.first
         unless l.node? || l == RDF.nil
-          add_debug "is_valid_list: false, #{l.inspect}"
+          add_debug {"is_valid_list: false, #{l.inspect}"}
           return false
         end
         props = @graph.properties(l)
       end
-      add_debug "is_valid_list: valid"
+      add_debug {"is_valid_list: valid"}
       true
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-ld
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,23 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-05 00:00:00.000000000 -07:00
-default_executable: 
+date: 2011-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
-  requirement: &2168459600 !ruby/object:Gem::Requirement
+  requirement: &2169730540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.3.3
+        version: 0.3.4
   type: :runtime
   prerelease: false
-  version_requirements: *2168459600
+  version_requirements: *2169730540
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &2168459140 !ruby/object:Gem::Requirement
+  requirement: &2169729780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +32,10 @@ dependencies:
         version: 1.5.1
   type: :runtime
   prerelease: false
-  version_requirements: *2168459140
+  version_requirements: *2169729780
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &2168458680 !ruby/object:Gem::Requirement
+  requirement: &2169728940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +43,10 @@ dependencies:
         version: 0.6.0
   type: :development
   prerelease: false
-  version_requirements: *2168458680
+  version_requirements: *2169728940
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2168458220 !ruby/object:Gem::Requirement
+  requirement: &2169727620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,21 +54,21 @@ dependencies:
         version: 2.5.0
   type: :development
   prerelease: false
-  version_requirements: *2168458220
+  version_requirements: *2169727620
 - !ruby/object:Gem::Dependency
   name: rdf-spec
-  requirement: &2168457760 !ruby/object:Gem::Requirement
+  requirement: &2169703000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.3.2
+        version: 0.3.4
   type: :development
   prerelease: false
-  version_requirements: *2168457760
+  version_requirements: *2169703000
 - !ruby/object:Gem::Dependency
   name: rdf-n3
-  requirement: &2168487740 !ruby/object:Gem::Requirement
+  requirement: &2169702100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -77,10 +76,10 @@ dependencies:
         version: 0.3.3
   type: :development
   prerelease: false
-  version_requirements: *2168487740
+  version_requirements: *2169702100
 - !ruby/object:Gem::Dependency
   name: rdf-isomorphic
-  requirement: &2168487280 !ruby/object:Gem::Requirement
+  requirement: &2169700640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -88,10 +87,10 @@ dependencies:
         version: 0.3.4
   type: :development
   prerelease: false
-  version_requirements: *2168487280
+  version_requirements: *2169700640
 - !ruby/object:Gem::Dependency
   name: sxp
-  requirement: &2168486820 !ruby/object:Gem::Requirement
+  requirement: &2169698280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -99,10 +98,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2168486820
+  version_requirements: *2169698280
 - !ruby/object:Gem::Dependency
   name: sparql-algebra
-  requirement: &2168486360 !ruby/object:Gem::Requirement
+  requirement: &2169697020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -110,10 +109,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2168486360
+  version_requirements: *2169697020
 - !ruby/object:Gem::Dependency
   name: sparql-grammar
-  requirement: &2168485900 !ruby/object:Gem::Requirement
+  requirement: &2169695840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -121,7 +120,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2168485900
+  version_requirements: *2169695840
 description: JSON-LD reader/writer for Ruby.
 email: public-rdf-ruby@w3.org
 executables: []
@@ -134,11 +133,11 @@ files:
 - VERSION
 - lib/json/ld/extensions.rb
 - lib/json/ld/format.rb
+- lib/json/ld/normalize.rb
 - lib/json/ld/reader.rb
 - lib/json/ld/version.rb
 - lib/json/ld/writer.rb
 - lib/json/ld.rb
-has_rdoc: false
 homepage: http://github.com/gkellogg/json-ld
 licenses:
 - Public Domain
@@ -160,7 +159,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: json-ld
-rubygems_version: 1.6.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: JSON-LD reader/writer for Ruby.