json-ld 0.1.2 → 0.1.3

data/History.markdown

@@ -1,3 +1,6 @@
+=== 0.1.3
+* Progress release syncing with the spec. Most expansion and compaction tests pass. RDF is okay, framing has many issues.
+
 === 0.1.1
 * Changed @literal to @value.
 * Change expanded double format to %1.6e

data/README.markdown

@@ -4,8 +4,7 @@
 
 ## Features
 
-JSON::LD parses and serializes [JSON-LD][] into [RDF][] and implements
-JSON::LD expansion, compaction and framing API interfaces.
+JSON::LD parses and serializes [JSON-LD][] into [RDF][] and implements expansion, compaction and framing API interfaces.
 
 Install with `gem install json-ld`
 
@@ -232,7 +231,7 @@ To install the latest official release of the `JSON-LD` gem, do:
 ## Download
 To get a local working copy of the development repository, do:
 
-    % git clone git://github.com/gkellogg/json-ld.git
+    % git clone git://github.com/ruby-rdf/json-ld.git
 
 ## Mailing List
 * <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
@@ -264,6 +263,6 @@ see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [YARD]:             http://yardoc.org/
 [YARD-GS]:          http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
 [PDD]:              http://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
-[RDF.rb]:           http://rdf.rubyforge.org/
+[RDF.rb]:           http://rubygems.org/gems/rdf
 [Backports]:        http://rubygems.org/gems/backports
 [JSON-LD]:          http://json-ld.org/spec/latest/

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.1.3

data/lib/json/ld.rb

@@ -16,7 +16,7 @@ module JSON
   #     end
   #   end
   #
-  # @see http://rdf.rubyforge.org/
+  # @see http://rubygems.org/gems/rdf
   # @see http://www.w3.org/TR/REC-rdf-syntax/
   #
   # @author [Gregg Kellogg](http://greggkellogg.net/)

data/lib/json/ld/api.rb

@@ -117,7 +117,6 @@ module JSON::LD
     # @option options [Boolean] :optimize (false)
     #   Perform further optimmization of the compacted output.
     #   (Presently, this is a noop).
-    # @param  [Hash{Symbol => Object}] options
     # @yield jsonld
     # @yieldparam [Hash] jsonld
     #   The compacted JSON-LD document
@@ -130,15 +129,10 @@ module JSON::LD
 
       # 1) Perform the Expansion Algorithm on the JSON-LD input.
       #    This removes any existing context to allow the given context to be cleanly applied.
-      API.new(input, nil, options) do
-        expanded = expand(value, nil, self.context)
-        debug(".compact") {"expanded input: #{value.to_json(JSON_STATE)}"}
-
-        # x) If no context provided, use context from input document
-        context ||= value.fetch('@context', nil)
-      end
+      expanded = API.expand(input, nil, nil, options)
 
       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
@@ -265,7 +259,6 @@ module JSON::LD
     #   Alternative to using block, with same parameteres.
     # @param [{Symbol,String => Object}] options
     #   Options passed to {#expand}
-    # @param  [Hash{Symbol => Object}] options
     # @raise [InvalidContext]
     # @yield statement
     # @yieldparam [RDF::Statement] statement
@@ -295,6 +288,7 @@ module JSON::LD
     # @param [Proc] callback (&block)
     #   Alternative to using block, with same parameteres.
     # @param  [Hash{Symbol => Object}] options
+    # @option options [Boolean] :notType don't use @type for rdf:type
     # @yield jsonld
     # @yieldparam [Hash] jsonld
     #   The JSON-LD document in expanded form
@@ -304,7 +298,7 @@ module JSON::LD
       result = nil
 
       API.new(nil, nil, options) do |api|
-        result = api.from_statements(input, BlankNodeNamer.new("t"))
+        result = api.from_statements(input)
       end
 
       callback.call(result) if callback

data/lib/json/ld/compact.rb

@@ -7,7 +7,6 @@ module JSON::LD
     #
     # @param [Array, Hash] element
     # @param [String] property (nil)
-    # @param [EvaluationContext] context
     # @return [Array, Hash]
     def compact(element, property = nil)
       if property.nil?
@@ -68,6 +67,7 @@ module JSON::LD
 
           if %(@id @type).include?(key)
             compacted_key = context.compact_iri(key, :position => :predicate, :depth => @depth)
+
             result[compacted_key] = case value
             when String
               # If value is a string, the compacted value is the result of performing IRI Compaction on value.
@@ -84,6 +84,7 @@ module JSON::LD
             if value.empty?
               # Make sure that an empty array is preserved
               compacted_key = context.compact_iri(key, :position => :predicate, :depth => @depth)
+              next if compacted_key.nil?
               result[compacted_key] = value
             end
 
@@ -92,6 +93,7 @@ module JSON::LD
             value.each do |item|
               compacted_key = context.compact_iri(key, :position => :predicate, :value => item, :depth => @depth)
               debug {" => compacted key: #{compacted_key.inspect} for #{item.inspect}"}
+              next if compacted_key.nil?
 
               compacted_item = depth {self.compact(item, compacted_key)}
               debug {" => compacted value: #{compacted_value.inspect}"}

data/lib/json/ld/evaluation_context.rb

@@ -103,8 +103,7 @@ module JSON::LD
 
     # Create an Evaluation Context using an existing context as a start by parsing the input.
     #
-    # @param [String, #read, Array, Hash, EvaluatoinContext] input
-    # @return [EvaluationContext] context
+    # @param [String, #read, Array, Hash, EvaluatoinContext] context
     # @raise [InvalidContext]
     #   on a remote context load error, syntax error, or a reference to a term which is not defined.
     def parse(context)
@@ -119,8 +118,7 @@ module JSON::LD
         # Load context document, if it is a string
         begin
           ctx = JSON.load(context)
-          raise JSON::LD::InvalidContext::Syntax, "missing @context" unless ctx.is_a?(Hash) && ctx["@context"]
-          parse(ctx["@context"])
+          parse(ctx["@context"] || {})
         rescue JSON::ParserError => e
           debug("parse") {"Failed to parse @context from remote document at #{context}: #{e.message}"}
           raise JSON::LD::InvalidContext::Syntax, "Failed to parse remote context at #{context}: #{e.message}" if @options[:validate]
@@ -161,7 +159,7 @@ module JSON::LD
           context.each do |key, value|
             # Expand a string value, unless it matches a keyword
             debug("parse") {"Hash[#{key}] = #{value.inspect}"}
-            if key == '@language'
+            if key == '@language' && (value.nil? || value.is_a?(String))
               new_ec.default_language = value
             elsif term_valid?(key)
               # Remove all coercion information for the property
@@ -174,7 +172,9 @@ module JSON::LD
               raise InvalidContext::Syntax, "unknown mapping for #{key.inspect} to #{value.class}" unless value.is_a?(String) || value.nil?
 
               iri = new_ec.expand_iri(value, :position => :predicate) if value.is_a?(String)
-              if iri && new_ec.mappings.fetch(key, nil) != iri
+              if iri && KEYWORDS.include?(key)
+                raise InvalidContext::Syntax, "key #{key.inspect} must not be a keyword"
+              elsif iri && new_ec.mappings.fetch(key, nil) != iri
                 # Record term definition
                 new_ec.set_mapping(key, iri)
                 num_updates += 1
@@ -325,23 +325,20 @@ module JSON::LD
     ##
     # Set term mapping
     #
-    # @param [String] term
+    # @param [#to_s] term
     # @param [RDF::URI, String] value
     #
     # @return [RDF::URI, String]
     def set_mapping(term, value)
+      term = term.to_s
+      term_sym = term.empty? ? "" : term.to_sym
 #      raise InvalidContext::Syntax, "mapping term #{term.inspect} must be a string" unless term.is_a?(String)
 #      raise InvalidContext::Syntax, "mapping value #{value.inspect} must be an RDF::URI" unless value.nil? || value.to_s[0,1] == '@' || value.is_a?(RDF::URI)
-      debug {"map #{term.inspect} to #{value}"} unless @mappings[term] == value
+      debug {"map #{term.inspect} to #{value.inspect}"}
       iri_to_term.delete(@mappings[term].to_s) if @mappings[term]
-      if value
-        @mappings[term] = value
-        @options[:prefixes][term] = value if @options.has_key?(:prefixes)
-        iri_to_term[value.to_s] = term
-      else
-        @mappings.delete(term)
-        nil
-      end
+      @mappings[term] = value
+      @options[:prefixes][term_sym] = value if @options.has_key?(:prefixes)
+      iri_to_term[value.to_s] = term
     end
 
     ##
@@ -366,7 +363,8 @@ module JSON::LD
     # @return [RDF::URI, '@id']
     def coerce(property)
       # Map property, if it's not an RDF::Value
-      return '@id' if [RDF.type, '@type'].include?(property)  # '@type' always is an IRI
+      # @type and @graph always is an IRI
+      return '@id' if [RDF.type, '@type', '@graph'].include?(property)
       @coercions.fetch(property, nil)
     end
 
@@ -459,15 +457,14 @@ module JSON::LD
       base = self.base unless [:predicate, :datatype].include?(options[:position])
       prefix = prefix.to_s
       case
-      when prefix == '_' && suffix          then debug("=> bnode"); bnode(suffix)
-      when iri.to_s[0,1] == "@"             then debug("=> keyword"); iri
-      when suffix.to_s[0,2] == '//'         then debug("=> iri"); uri(iri)
-      when mappings.has_key?(prefix)        then debug("=> curie"); uri(mappings[prefix] + suffix.to_s)
-      when base                             then debug("=> base"); base.join(iri)
+      when prefix == '_' && suffix          then bnode(suffix)
+      when iri.to_s[0,1] == "@"             then iri
+      when suffix.to_s[0,2] == '//'         then uri(iri)
+      when mappings.has_key?(prefix)        then uri(mappings[prefix] + suffix.to_s)
+      when base                             then base.join(iri)
       else
         # Otherwise, it must be an absolute IRI
         u = uri(iri)
-        debug("=> absolute") {"#{u.inspect} abs? #{u.absolute?.inspect}"}
         u if u.absolute? || [:subject, :object].include?(options[:position])
       end
     end
@@ -487,10 +484,6 @@ module JSON::LD
     # @return [String] compacted form of IRI
     # @see http://json-ld.org/spec/latest/json-ld-api/#iri-compaction
     def compact_iri(iri, options = {})
-      # Don't cause these to be compacted
-      return iri.to_s if [RDF.first, RDF.rest, RDF.nil].include?(iri)
-      return self.alias('@type') if options[:position] == :predicate && iri == RDF.type
-
       depth(options) do
         debug {"compact_iri(#{iri.inspect}, #{options.inspect})"}
 
@@ -547,9 +540,15 @@ module JSON::LD
         # @type coercion, @container coercion or @language coercion rules
         # along with the iri itself.
         if terms.empty?
-          curies = mappings.keys.map {|k| iri.to_s.sub(mapping(k).to_s, "#{k}:") if
-            iri.to_s.index(mapping(k).to_s) == 0 &&
-            iri.to_s != mapping(k).to_s}.compact
+          debug("curies") {"mappings: #{mappings.inspect}"}
+          curies = mappings.keys.map do |k|
+            debug("curies[#{k}]") {"#{mapping(k).inspect}"}
+            #debug("curies[#{k}]") {"#{(mapping(k).to_s.length > 0).inspect}, #{iri.to_s.index(mapping(k).to_s)}"}
+            iri.to_s.sub(mapping(k).to_s, "#{k}:") if
+              mapping(k).to_s.length > 0 &&
+              iri.to_s.index(mapping(k).to_s) == 0 &&
+              iri.to_s != mapping(k).to_s
+          end.compact
 
           debug("curies") do
             curies.map do |c|
@@ -581,17 +580,24 @@ module JSON::LD
             debug("curies") {"using standard prefies: #{terms.inspect}"}
           end
 
-          terms << iri.to_s
+          # If there is a mapping from the complete IRI to null, return null,
+          # otherwise, return the complete IRI.
+          if mappings.has_key?(iri.to_s) && !mapping(iri)
+            debug("iri") {"use nil IRI mapping"}
+            terms << nil
+          else
+            terms << iri.to_s
+          end
         end
         
         # Get the first term based on distance and lexecographical order
         # Prefer terms that don't have @container @set over other terms, unless as set is true
         terms = terms.sort do |a, b|
           debug("term sort") {"c(a): #{container(a).inspect}, c(b): #{container(b)}"}
-          if a.length == b.length
-            a <=> b
+          if a.to_s.length == b.to_s.length
+            a.to_s <=> b.to_s
           else
-            a.length <=> b.length
+            a.to_s.length <=> b.to_s.length
           end
         end
         debug("sorted terms") {terms.inspect}
@@ -613,11 +619,13 @@ module JSON::LD
     # @param [Hash, String] value
     #   Value (literal or IRI) to be expanded
     # @param  [Hash{Symbol => Object}] options
+    # @option options [Boolean] :native (true) use native representations
     #
     # @return [Hash] Object representation of value
     # @raise [RDF::ReaderError] if the iri cannot be expanded
     # @see http://json-ld.org/spec/latest/json-ld-api/#value-expansion
     def expand_value(property, value, options = {})
+      options = {:native => true}.merge(options)
       depth(options) do
         debug("expand_value") {"property: #{property.inspect}, value: #{value.inspect}, coerce: #{coerce(property).inspect}"}
         result = case value
@@ -626,8 +634,12 @@ module JSON::LD
           when RDF::XSD.double.to_s
             {"@value" => value.to_s, "@type" => RDF::XSD.double.to_s}
           else
-            # Unless there's coercion, to not modify representation
-            value.is_a?(RDF::Literal::Boolean) ? value.object : value
+            if options[:native]
+              # Unless there's coercion, to not modify representation
+              {"@value" => (value.is_a?(RDF::Literal::Boolean) ? value.object : value)}
+            else
+              {"@value" => value.to_s, "@type" => RDF::XSD.boolean.to_s}
+            end
           end
         when Integer, RDF::Literal::Integer
           case coerce(property)
@@ -635,7 +647,11 @@ module JSON::LD
             {"@value" => RDF::Literal::Double.new(value, :canonicalize => true).to_s, "@type" => RDF::XSD.double.to_s}
           when RDF::XSD.integer.to_s, nil
             # Unless there's coercion, to not modify representation
-            value.is_a?(RDF::Literal::Integer) ? value.object : value
+            if options[:native]
+              {"@value" => value.is_a?(RDF::Literal::Integer) ? value.object : value}
+            else
+              {"@value" => value.to_s, "@type" => RDF::XSD.integer.to_s}
+            end
           else
             res = Hash.ordered
             res['@value'] = value.to_s
@@ -649,8 +665,12 @@ module JSON::LD
           when RDF::XSD.double.to_s
             {"@value" => RDF::Literal::Double.new(value, :canonicalize => true).to_s, "@type" => RDF::XSD.double.to_s}
           when nil
-            # Unless there's coercion, to not modify representation
-            value.is_a?(RDF::Literal::Double) ? value.object : value
+            if options[:native]
+              # Unless there's coercion, to not modify representation
+              {"@value" => value.is_a?(RDF::Literal::Double) ? value.object : value}
+            else
+              {"@value" => RDF::Literal::Double.new(value, :canonicalize => true).to_s, "@type" => RDF::XSD.double.to_s}
+            end
           else
             res = Hash.ordered
             res['@value'] = value.to_s
@@ -676,7 +696,7 @@ module JSON::LD
             {'@id' => expand_iri(value, :position => :object).to_s}
           when nil
             debug("expand value") {"lang(prop): #{language(property).inspect}, def: #{default_language.inspect}"}
-            language(property) ? {"@value" => value.to_s, "@language" => language(property)} : value.to_s
+            language(property) ? {"@value" => value.to_s, "@language" => language(property)} : {"@value" => value.to_s}
           else
             res = Hash.ordered
             res['@value'] = value.to_s
@@ -702,6 +722,7 @@ module JSON::LD
     # @return [Hash] Object representation of value
     # @raise [ProcessingError] if the iri cannot be expanded
     # @see http://json-ld.org/spec/latest/json-ld-api/#value-compaction
+    # FIXME: revisit the specification version of this.
     def compact_value(property, value, options = {})
       raise ProcessingError::Lossy, "attempt to compact a non-object value: #{value.inspect}" unless value.is_a?(Hash)
 
@@ -709,11 +730,11 @@ module JSON::LD
         debug("compact_value") {"property: #{property.inspect}, value: #{value.inspect}, coerce: #{coerce(property).inspect}"}
 
         result = case
-        when %w(boolean integer double).any? {|t| expand_iri(value['@type'], :position => :datatype) == RDF::XSD[t]}
-          # Compact native type
-          debug {" (native)"}
-          l = RDF::Literal(value['@value'], :datatype => expand_iri(value['@type'], :position => :datatype))
-          l.canonicalize.object
+          #when %w(boolean integer double).any? {|t| expand_iri(value['@type'], :position => :datatype) == RDF::XSD[t]}
+        #  # Compact native type
+        #  debug {" (native)"}
+        #  l = RDF::Literal(value['@value'], :datatype => expand_iri(value['@type'], :position => :datatype))
+        #  l.canonicalize.object
         when coerce(property) == '@id' && value.has_key?('@id')
           # Compact an @id coercion
           debug {" (@id & coerce)"}
@@ -731,10 +752,18 @@ module JSON::LD
           # Compact language
           debug {" (@language) == #{language(property).inspect}"}
           value['@value']
+        when value['@value'] && !value['@value'].is_a?(String)
+          # Compact simple literal to string
+          debug {" (@value not string)"}
+          value['@value']
         when value['@value'] && !value['@language'] && !value['@type'] && !coerce(property) && !default_language
           # Compact simple literal to string
           debug {" (@value && !@language && !@type && !coerce && !language)"}
           value['@value']
+        when value['@value'] && !value['@language'] && !value['@type'] && !coerce(property) && !language(property)
+          # Compact simple literal to string
+          debug {" (@value && !@language && !@type && !coerce && language(property).false)"}
+          value['@value']
         when value['@type']
           # Compact datatype
           debug {" (@type)"}
@@ -814,51 +843,47 @@ module JSON::LD
     # @param [Object] value
     # @return [Integer]
     def term_rank(term, value)
-      debug("term rank") { "term: #{term.inspect}, value: #{value.inspect}"}
-      debug("term rank") { "coerce: #{coerce(term).inspect}, lang: #{languages.fetch(term, nil).inspect}"}
-
-      # A term without @language or @type can be used with rank 1 for any value
       default_term = !coerce(term) && !languages.has_key?(term)
-      debug("term rank") { "default_term: #{default_term.inspect}"}
-
-      rank = case value
-      when TrueClass, FalseClass
-        coerce(term) == RDF::XSD.boolean.to_s ? 3 : (default_term ? 2 : 1)
-      when Integer
-        coerce(term) == RDF::XSD.integer.to_s ? 3 : (default_term ? 2 : 1)
-      when Float
-        coerce(term) == RDF::XSD.double.to_s ? 3 : (default_term ? 2 : 1)
-      when nil
-        # A value of null probably means it's an @id
+      debug("term rank") {
+        "term: #{term.inspect}, " +
+        "value: #{value.inspect}, " +
+        "coerce: #{coerce(term).inspect}, " +
+        "lang: #{languages.fetch(term, nil).inspect}/#{language(term).inspect} " +
+        "default_term: #{default_term.inspect}"
+      }
+
+      # value is null
+      rank = if value.nil?
+        debug("term rank") { "null value: 3"}
         3
-      when String
-        # When compacting a string, the string has no language, so the term can be used if the term has @language null or it is a default term and there is no default language
-        debug("term rank") {"string: lang: #{languages.fetch(term, false).inspect}, def: #{default_language.inspect}"}
-        !languages.fetch(term, true) || (default_term && !default_language) ? 3 : 0
-      when Hash
-        if list?(value)
-          if value['@list'].empty?
-            # If the @list property is an empty array, if term has @container set to @list, term rank is 1, otherwise 0.
-            container(term) == '@list' ? 1 : 0
-          else
-            # Otherwise, return the sum of the term ranks for every entry in the list.
-            depth {value['@list'].inject(0) {|memo, v| memo + term_rank(term, v)}}
-          end
-        elsif subject?(value) || subject_reference?(value)
-          coerce(term) == '@id' ? 3 : (default_term ? 1 : 0)
-        elsif val_type = value.fetch('@type', nil)
+      elsif list?(value)
+        if value['@list'].empty?
+          # If the @list property is an empty array, if term has @container set to @list, term rank is 1, otherwise 0.
+          container(term) == '@list' ? 1 : 0
+        else
+          # Otherwise, return the sum of the term ranks for every entry in the list.
+          depth {value['@list'].inject(0) {|memo, v| memo + term_rank(term, v)}}
+        end
+      elsif value?(value)
+        val_type = value.fetch('@type', nil)
+        val_lang = value.fetch('@language', nil)
+        debug("term rank") {"@val_type: #{val_type.inspect}, val_lang: #{val_lang.inspect}"}
+        if val_type
           coerce(term) == val_type ? 3 :  (default_term ? 1 : 0)
-        elsif val_lang = value.fetch('@language', nil)
-          val_lang == language(term) ? 3 : (default_term ? 1 : 0)
+        elsif !value['@value'].is_a?(String)
+          default_term ? 2 : 1
+        elsif val_lang.nil?
+          debug("val_lang.nil") {"#{language(term).inspect} && #{coerce(term).inspect}"}
+          !language(term) && !coerce(term) ? 3 : 0
         else
-          default_term ? 3 : 0
+          val_lang == language(term) ? 3 : (default_term ? 1 : 0)
         end
-      else
-        raise ProcessingError, "Unexpected value for term_rank: #{value.inspect}"
+      else # subject definition/reference
+        coerce(term) == '@id' ? 3 : (default_term ? 1 : 0)
       end
       
-      # If term has @container @set, and rank is not 0, increase rank by 1.
-      rank > 0 && container(term) == '@set' ? rank + 1 : rank
+      debug(" =>") {rank.inspect}
+      rank
     end
   end
-end
+end

data/lib/json/ld/expand.rb

@@ -53,7 +53,7 @@ module JSON::LD
 
             # Set active property to the original un-expanded property if property if not a keyword
             active_property = key unless key[0,1] == '@'
-            debug("expand property") {"#{active_property}, expanded: #{property}, value: #{value.inspect}"}
+            debug("expand property") {"#{active_property.inspect}, expanded: #{property}, value: #{value.inspect}"}
           
             # If property does not expand to a keyword or absolute IRI, remove property from element
             # and continue to the next property from element
@@ -71,17 +71,25 @@ module JSON::LD
               # Otherwise, if the property is @type the value must be a string, an array of strings
               # or an empty JSON Object.
               # Expand value or each of it's entries according to IRI Expansion
+              debug("@type") {"value: #{value.inspect}"}
               case value
               when Array
                 depth do
                   [value].flatten.map do |v|
+                    v = v['@id'] if subject_reference?(v)
+                    raise ProcessingError, "Object value must be a string or a subject reference: #{v.inspect}" unless v.is_a?(String)
                     context.expand_iri(v, options.merge(:position => :property, :quiet => true)).to_s
                   end
                 end
               when Hash
-                # Empty object used for @type wildcard
-                raise ProcessingError, "Object value of @type must be empty: #{value.inspect}" unless value.empty?
-                value
+                # Empty object used for @type wildcard or subject reference
+                if subject_reference?(value)
+                  context.expand_iri(value['@id'], options.merge(:position => :property, :quiet => true)).to_s
+                elsif !value.empty?
+                  raise ProcessingError, "Object value of @type must be empty or a subject reference: #{value.inspect}"
+                else
+                  value
+                end
               else
                 context.expand_iri(value, options.merge(:position => :property, :quiet => true)).to_s
               end
@@ -152,10 +160,8 @@ module JSON::LD
               raise ProcessingError, "element must not have more than one other property, which can either be @language or @type with a string value." unless value.is_a?(String)
             end
 
-            # if @value is the only property or the value of @value equals null, replace element with the value of @value.
-            if output_object['@value'].nil? || output_object.keys.length == 1
-              return output_object['@value']
-            end
+            # if the value of @value equals null, replace element with the value of null.
+            return nil if output_object['@value'].nil?
           elsif !output_object.fetch('@type', []).is_a?(Array)
             # Otherwise, if element has an @type property and it's value is not in the form of an array,
             # convert it to an array.

data/lib/json/ld/frame.rb

@@ -244,7 +244,7 @@ module JSON::LD
       debug("flatten") {"statements: #{statements.map(&:to_nquads).join("\n")}"}
 
       # Transform back to JSON-LD, not flattened
-      depth {self.from_statements(statements, BlankNodeNamer.new("t"))}
+      depth {self.from_statements(statements)}
     end
 
     ##

data/lib/json/ld/from_rdf.rb

@@ -9,14 +9,10 @@ module JSON::LD
     # Representation is in expanded form
     #
     # @param [Array<RDF::Statement>] input
-    # @param [BlankNodeNamer] namer
     # @return [Array<Hash>] the JSON-LD document in normalized form
-    def from_statements(input, namer)
-      array = []
-      listMap = {}
-      restMap = {}
-      subjectMap = {}
-      bnode_map = {}
+    def from_statements(input)
+      defaultGraph = {:subjects => {}, :listMap => {}, :name => ''}
+      graphs = {'' => defaultGraph}
 
       value = nil
       ec = EvaluationContext.new
@@ -28,20 +24,21 @@ module JSON::LD
         debug("statement") { statement.to_nquads.chomp}
 
         subject = ec.expand_iri(statement.subject).to_s
-        name = ec.expand_iri(statement.context).to_s if statement.context
-        subject = namer.get_name(subject) if subject[0,2] == "_:"
-        name = namer.get_name(name) if name.to_s[0,2] == "_:"
-
+        name = statement.context ? ec.expand_iri(statement.context).to_s : ''
+        
+        # Create a graph entry as needed
+        graph = graphs[name] ||= {:subjects => {}, :listMap => {}, :name => name}
+        
         case statement.predicate
         when RDF.first
           # If property is rdf:first,
           # create a new entry in _listMap_ for _name_ and _subject_ and an array value
           # containing the object representation and continue to the next statement.
+          listMap = graph[:listMap]
+          entry = listMap[subject] ||= {}
           object_rep = ec.expand_value(nil, statement.object)
-          object_rep['@id'] = namer.get_name(object_rep['@id']) if blank_node?(object_rep)
-          debug("rdf:first") { "save object #{[object_rep].inspect}"}
-          listMap[name] ||= {}
-          listMap[name][subject] = [object_rep]
+          entry[:first] = object_rep
+          debug("rdf:first") { "save entry for #{subject.inspect} #{entry.inspect}"}
           next
         when RDF.rest
           # If property is rdf:rest,
@@ -49,64 +46,26 @@ module JSON::LD
           # create a new entry in _restMap_ for _name_ and _subject_ and a value being the
           # result of IRI expansion on the object and continue to the next statement.
           next unless statement.object.is_a?(RDF::Node)
+
+          listMap = graph[:listMap]
+          entry = listMap[subject] ||= {}
+
           object_rep = ec.expand_iri(statement.object).to_s
-          object_rep = namer.get_name(object_rep) if object_rep[0,2] == '_:'
-          debug("rdf:rest") { "save object #{object_rep.inspect}"}
-          restMap[name] ||= {}
-          restMap[name][subject] = object_rep
+          entry[:rest] = object_rep
+          debug("rdf:rest") { "save entry for #{subject.inspect} #{entry.inspect}"}
           next
         end
 
-        # If name is not null
-        if name
-          # If _subjectMap_ does not have an entry for null as name and _name_ as subject
-          subjectMap[nil] ||= {}
-          value = subjectMap[nil][name]
-          unless value
-            # Create a new JSON Object with key/value pair of @id and a string representation
-            # of name and append to array.
-            debug("@id") { "new subject: #{name} for graph"}
-            value = Hash.ordered
-            value['@id'] = name
-            array << (subjectMap[nil][name] = value)
-          else
-            # Otherwise, use that entry as value
-          end
-
-          # If value does not have an entry for @graph, initialize it as a new array
-          a = value['@graph'] ||= []
-
-          # If subjectMap does not have an entry for name and subject
-          subjectMap[name] ||= {}
-          value = subjectMap[name][subject]
-          unless value
-            # Create a new JSON Object with key/value pair of @id and a string representation
-            # of name and append to the the graph array for name and use as value.
-            debug("@id") { "new subject: #{subject} for graph: #{name}"}
-            value = Hash.ordered
-            value['@id'] = subject
-            a << (subjectMap[name][subject] = value)
-          else
-            # Otherwise, use that entry as value
-          end
-        else
-          # Otherwise, if subjectMap does not have an entry for _name_ and _subject_
-          subjectMap[name] ||= {}
-          value = subjectMap[nil][subject]
-          unless value
-            # Create a new JSON Object with key/value pair of @id and a string representation
-            # of subject and append to array.
-            debug("@id") { "new subject: #{subject}"}
-            value = Hash.ordered
-            value['@id'] = subject
-            array << (subjectMap[nil][subject] = value)
-          else
-            # Otherwise, use that entry as value
-          end
-        end
+        # Add entry to default graph for name unless it is empty
+        defaultGraph[:subjects][name] ||= {'@id' => name} unless name.empty?
         
-        # If property is http://www.w3.org/1999/02/22-rdf-syntax-ns#type:
-        if statement.predicate == RDF.type
+        # 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}
+
+        # If property is http://www.w3.org/1999/02/22-rdf-syntax-ns#type
+        # 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
@@ -117,45 +76,65 @@ module JSON::LD
           # key be the string representation of predicate. Set the value
           # for key to an empty @list representation {"@list": []}
           key = ec.expand_iri(statement.predicate).to_s
-          value[key] = {"@list" => []}
+          (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.
           key = ec.expand_iri(statement.predicate).to_s
-          object = ec.expand_value(key, statement.object)
-          debug("object") {"detected that #{object.inspect} is a blank node"}
-          object['@id'] = object_iri = namer.get_name(object['@id']) if blank_node?(object)
+          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
+            listMap = graph[:listMap]
+            entry = listMap[object['@id']] ||= {}
+            entry[:head] = object
+            debug("bnode") { "save entry #{entry.inspect}"}
+          end
 
           debug("key/value") { "key: #{key}, :value #{object.inspect}"}
           
-          # Non-normative, save a reference for the bnode to allow for easier list expansion
-          bnode_map[object_iri] = {:obj => value, :key => key} if statement.object.is_a?(RDF::Node)
-
           # append the object object representation to the array value for key, creating
           # an entry if necessary
           (value[key] ||= []) << object
         end
       end
 
-      # For each key/value _prev_, _rest_ entry in _restMap_, append to the _listMap_ value identified
-      # by _prev_ the _listMap_ value identified by _rest_
-      debug("restMap") {restMap.inspect}
-      restMap.each do |gname, map|
-        map.each do |prev, rest|
-          debug("@list") { "Fold #{rest} into #{prev}"}
-          listMap[gname][prev] += listMap[gname][rest]
+      # Build lists for each graph
+      graphs.each do |name, graph|
+        graph[:listMap].each do |subject, entry|
+          debug("listMap(#{name}, #{subject})") { entry.inspect}
+          if entry.has_key?(:head) && entry.has_key?(:first)
+            debug("@list") { "List head for #{subject.inspect} in #{name.inspect}: #{entry.inspect}"}
+            value = entry[:head]
+            value.delete('@id')
+            list = value['@list'] = [entry[:first]].compact
+            
+            while rest = entry.fetch(:rest, nil)
+              entry = graph[:listMap][rest]
+              debug(" => ") { "add #{entry.inspect}"}
+              raise JSON::LD::ProcessingError, "list entry missing rdf:first" unless entry.has_key?(:first)
+              list << entry[:first]
+            end
+          end
         end
       end
 
-      # For each key/value _node_, _list_, in _listMap_ where _list_ exists as a value of an object in _array_,
-      # replace the object value with _list_
-      debug("listMap") {listMap.inspect}
-      listMap.each do |gname, map|
-        map.each do |node, list|
-          next unless bnode_map.has_key?(node)
-          debug("@list") { "Replace #{bnode_map[node][:obj][bnode_map[node][:key]]} with #{listMap[node]}"}
-          bnode_map[node][:obj][bnode_map[node][:key]] = {"@list" => listMap[gname][node]}
+      # Build graphs in @id order
+      debug("graphs") {graphs.to_json(JSON_STATE)}
+      array = defaultGraph[:subjects].keys.sort.map do |subject|
+        entry = defaultGraph[:subjects][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|
+            debug("=> #{s.inspect}")
+            graphs[subject][:subjects][s]
+          end
         end
+        
+        debug("default graph") {entry.inspect}
+        entry
       end
 
       # Return array as the graph representation.

data/lib/json/ld/to_rdf.rb

@@ -21,7 +21,7 @@ module JSON::LD
     # @yieldparam [RDF::Statement] :statement
     def statements(path, element, subject, property, name, &block)
       debug(path) {"statements: e=#{element.inspect}, s=#{subject.inspect}, p=#{property.inspect}, n=#{name.inspect}"}
-      @node_seq = "jld_t0000" unless subject || property
+      @node_seq = "t0" unless subject || property
 
       traverse_result = depth do
         case element
@@ -55,7 +55,8 @@ module JSON::LD
 
           # 1.7) For each key in the JSON object that has not already been processed,
           # perform the following steps:
-          element.each do |key, value|
+          element.keys.sort.each do |key|
+            value = element[key]
             active_property = case key
             when '@type'
               # If the key is @type, set the active property to rdf:type.
@@ -125,8 +126,6 @@ module JSON::LD
     #   Inherited property
     # @param [RDF::Resource] name
     #   Inherited named graph context
-    # @param [EvaluationContext] ec
-    #   The active context
     # @return [RDF::Resource] BNode or nil for head of list
     # @yield :statement
     # @yieldparam [RDF::Statement] :statement

data/lib/json/ld/utils.rb

@@ -39,12 +39,21 @@ module JSON::LD
       value.is_a?(Hash) && value.keys == %w(@list)
     end
 
+    ##
+    # Is value literal?
+    #
+    # @param [Object] value
+    # @return [Boolean]
+    def value?(value)
+      value.is_a?(Hash) && value.has_key?('@value')
+    end
+
     private
 
     # Add debug event to debug array, if specified
     #
-    # @param [String] message
-    # @yieldreturn [String] appended to message, to allow for lazy-evaulation of message
+    #   param [String] message
+    #   yieldreturn [String] appended to message, to allow for lazy-evaulation of message
     def debug(*args)
       return unless ::JSON::LD.debug? || @options[:debug]
       list = args

data/lib/json/ld/writer.rb

@@ -92,7 +92,7 @@ module JSON::LD
       options[:base_uri] ||= options[:base] if options.has_key?(:base)
       options[:base] ||= options[:base_uri] if options.has_key?(:base_uri)
       super do
-        @graph = RDF::Graph.new
+        @repo = RDF::Graph.new
 
         if block_given?
           case block.arity
@@ -110,7 +110,7 @@ module JSON::LD
     # @return [void]
     def write_graph(graph)
       debug {"Add graph #{graph.inspect}"}
-      @graph = graph
+      @repo = graph
     end
 
     ##
@@ -118,7 +118,7 @@ module JSON::LD
     # @param  [RDF::Statement] statement
     # @return [void]
     def write_statement(statement)
-      @graph.insert(statement)
+      @repo.insert(statement)
     end
 
     ##
@@ -130,7 +130,7 @@ module JSON::LD
     # @raise  [NotImplementedError] unless implemented in subclass
     # @abstract
     def write_triple(subject, predicate, object)
-      @graph.insert(Statement.new(subject, predicate, object))
+      @repo.insert(Statement.new(subject, predicate, object))
     end
 
     ##
@@ -145,7 +145,7 @@ module JSON::LD
       @debug = @options[:debug]
 
       # Turn graph into a triple array
-      statements = @graph.each_statement.to_a
+      statements = @repo.each_statement.to_a
       debug("writer") { "serialize #{statements.length} statements, #{@options.inspect}"}
       result = API.fromRDF(statements, nil, @options)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-ld
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-20 00:00:00.000000000Z
+date: 2012-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
-  requirement: &70185823761420 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: 0.3.5
   type: :runtime
   prerelease: false
-  version_requirements: *70185823761420
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.5
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &70185823760820 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +37,15 @@ dependencies:
         version: 1.6.5
   type: :runtime
   prerelease: false
-  version_requirements: *70185823760820
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.5
 - !ruby/object:Gem::Dependency
   name: equivalent-xml
-  requirement: &70185823760180 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +53,15 @@ dependencies:
         version: 0.2.8
   type: :development
   prerelease: false
-  version_requirements: *70185823760180
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.8
 - !ruby/object:Gem::Dependency
   name: open-uri-cached
-  requirement: &70185823759520 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +69,15 @@ dependencies:
         version: 0.0.5
   type: :development
   prerelease: false
-  version_requirements: *70185823759520
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.5
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &70185823758900 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +85,15 @@ dependencies:
         version: 0.7.4
   type: :development
   prerelease: false
-  version_requirements: *70185823758900
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.4
 - !ruby/object:Gem::Dependency
   name: spira
-  requirement: &70185823758300 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +101,15 @@ dependencies:
         version: 0.0.12
   type: :development
   prerelease: false
-  version_requirements: *70185823758300
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.12
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70185823757580 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +117,15 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *70185823757580
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.8.0
 - !ruby/object:Gem::Dependency
   name: rdf-spec
-  requirement: &70185823756980 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,10 +133,15 @@ dependencies:
         version: 0.3.5
   type: :development
   prerelease: false
-  version_requirements: *70185823756980
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.5
 - !ruby/object:Gem::Dependency
   name: rdf-turtle
-  requirement: &70185823756340 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -109,10 +149,15 @@ dependencies:
         version: 0.1.1
   type: :development
   prerelease: false
-  version_requirements: *70185823756340
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
   name: rdf-trig
-  requirement: &70185823755720 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -120,10 +165,15 @@ dependencies:
         version: 0.1.1
   type: :development
   prerelease: false
-  version_requirements: *70185823755720
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
   name: rdf-isomorphic
-  requirement: &70185823755100 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -131,10 +181,15 @@ dependencies:
         version: 0.3.4
   type: :development
   prerelease: false
-  version_requirements: *70185823755100
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.4
 - !ruby/object:Gem::Dependency
   name: sparql
-  requirement: &70185823754420 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -142,7 +197,28 @@ dependencies:
         version: 0.0.2
   type: :development
   prerelease: false
-  version_requirements: *70185823754420
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+- !ruby/object:Gem::Dependency
+  name: backports
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: JSON::LD parses and serializes JSON-LD into RDF and implements expansion,
   compaction and framing API interfaces.
 email: public-rdf-ruby@w3.org
@@ -190,7 +266,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: json-ld
-rubygems_version: 1.8.17
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: JSON-LD reader/writer for Ruby.