json-ld 1.99.0 → 1.99.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbd10c33d33b7cd63273e8f7a1f2aca15bd0c2fd
-  data.tar.gz: b4bcaa6cb6e5afb3ec20e3b9376e73b0a1666ac5
+  metadata.gz: 6ba81727972fdb49ae06b098ce1754bbab4fad06
+  data.tar.gz: 084a57e8647980ce9e972ffdeefa1725d5a90edb
 SHA512:
-  metadata.gz: f4fbfa5093a7396c09c04f611a9cf3071e8f68787cef16e389fecec055d1c2022bcbf605f209c66a476db0bf7922e52b8924f296a14f58cf1434c87b74a7be8b
-  data.tar.gz: b508589a20147522523e8d8e327a3dd0d2acb9b83d95b29604d825c5d6cb299026bd3aaa3ea830048b419384bd938cee4e04b55795b84e375ca99d572e2b800d
+  metadata.gz: d0fb6704553d2dbfa3ef5f65e006bdbb1c3fb2192d182c43606a6a9fb620303ff45500f613d970aa2a451f6722f25be00ff3b6bf0a0c335322e1855169560661
+  data.tar.gz: 9d0f250e54edb0f1cd2aa15e9c1282fc4cf7e87a6cc511db7afaa3cd0c73ed1b18b40debb369242ffac8205f1e41105c4b0a8794d82fda780bb8bb97b80832a1

data/VERSION

@@ -1 +1 @@
-1.99.0
+1.99.1

data/lib/json/ld/api.rb

@@ -413,22 +413,11 @@ module JSON::LD
         #    This removes any existing context to allow the given context to be cleanly applied.
         debug(".toRdf") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
 
-        # Generate _nodeMap_
-        graphs = {'@default' => {}}
-        create_node_map(expanded_input, graphs)
-        debug(".toRdf") {"node map: #{graphs.to_json(JSON_STATE) rescue 'malformed json'}"}
-
-        # Start generating statements
-        graphs.each do |graph_name, graph|
-          context = as_resource(graph_name) unless graph_name == '@default'
-          debug(".toRdf") {"graph_name: #{context ? context.to_ntriples : 'null'}"}
-          # Drop results for graphs which are named with relative IRIs
-          if graph_name.is_a?(RDF::URI) && !graph_name.absolute
-            debug(".toRdf") {"drop relative graph_name: #{statement.to_ntriples}"}
-            next
-          end
-          graph_to_rdf(graph) do |statement|
+        # Recurse through input
+        expanded_input.each do |node|
+          item_to_rdf(node) do |statement|
             next if statement.predicate.node? && !options[:produceGeneralizedRdf]
+
             # Drop results with relative IRIs
             relative = statement.to_a.any? do |r|
               case r
@@ -445,12 +434,7 @@ module JSON::LD
               next
             end
 
-            statement.graph_name = context if context
-            if block_given?
-              yield statement
-            else
-              results << statement
-            end
+            yield statement
           end
         end
       end

data/lib/json/ld/format.rb

@@ -1,25 +1,23 @@
 module JSON::LD
   ##
-  # RDFa format specification.
+  # JSON-LD format specification.
   #
-  # @example Obtaining an Notation3 format class
-  #     RDF::Format.for(:json)            #=> JSON::LD::Format
-  #     RDF::Format.for(:ld)              #=> JSON::LD::Format
-  #     RDF::Format.for("etc/foaf.json")
-  #     RDF::Format.for("etc/foaf.ld")
-  #     RDF::Format.for(:file_name      => "etc/foaf.json")
-  #     RDF::Format.for(:file_name      => "etc/foaf.ld")
-  #     RDF::Format.for(file_extension: "json")
-  #     RDF::Format.for(file_extension: "ld")
-  #     RDF::Format.for(:content_type   => "application/json")
+  # @example Obtaining an JSON-LD format class
+  #     RDF::Format.for(:jsonld)           #=> JSON::LD::Format
+  #     RDF::Format.for("etc/foaf.jsonld")
+  #     RDF::Format.for(:file_name         => "etc/foaf.jsonld")
+  #     RDF::Format.for(file_extension: "jsonld")
+  #     RDF::Format.for(:content_type   => "application/ld+json")
   #
   # @example Obtaining serialization format MIME types
-  #     RDF::Format.content_types      #=> {"application/json" => [JSON::LD::Format]}
+  #     RDF::Format.content_types      #=> {"application/ld+json" => [JSON::LD::Format],
+  #                                         "application/x-ld+json" => [JSON::LD::Format]}
   #
   # @example Obtaining serialization format file extension mappings
-  #     RDF::Format.file_extensions    #=> {json: "application/json"}
+  #     RDF::Format.file_extensions    #=> {:jsonld => [JSON::LD::Format] }
   #
-  # @see http://www.w3.org/TR/rdf-testcases/#ntriples
+  # @see http://www.w3.org/TR/json-ld/
+  # @see http://json-ld.org/test-suite/
   class Format < RDF::Format
     content_type     'application/ld+json',
                      extension: :jsonld,

data/lib/json/ld/to_rdf.rb

@@ -6,68 +6,14 @@ module JSON::LD
     include Utils
 
     ##
-    #
-    # @param [Hash{String => Hash}] active_graph
-    #   A hash of IRI to Node definitions
+    # @param [Hash{String => Object}] node
+    # @param [RDF::Resource] graph_name
     # @yield statement
     # @yieldparam [RDF::Statement] statement
-    def graph_to_rdf(active_graph, &block)
-      debug('graph_to_rdf') {"graph_to_rdf: #{active_graph.inspect}"}
-
-      # For each id-node in active_graph
-      active_graph.each do |id, node|
-        # Initialize subject as the IRI or BNode representation of id
-        subject = as_resource(id)
-        debug("graph_to_rdf")  {"subject: #{subject.to_ntriples rescue 'malformed rdf'} (id: #{id})"}
-
-        # For each property-values in node
-        node.each do |property, values|
-          case property
-          when '@type'
-            # If property is @type, construct triple as an RDF Triple composed of id, rdf:type, and object from values where id and object are represented either as IRIs or Blank Nodes
-            values.each do |value|
-              object = as_resource(value)
-              debug("graph_to_rdf")  {"type: #{object.to_ntriples rescue 'malformed rdf'}"}
-              yield RDF::Statement.new(subject, RDF.type, object)
-            end
-          when /^@/
-            # Otherwise, if @type is any other keyword, skip to the next property-values pair
-          else
-            # Otherwise, property is an IRI or Blank Node identifier
-            # Initialize predicate from  property as an IRI or Blank node
-            predicate = as_resource(property)
-            debug("graph_to_rdf")  {"predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
-
-            # For each item in values
-            values.each do |item|
-              if item.has_key?('@list')
-                debug("graph_to_rdf")  {"list: #{item.inspect}"}
-                # If item is a list object, initialize list_results as an empty array, and object to the result of the List Conversion algorithm, passing the value associated with the @list key from item and list_results.
-                object = parse_list(item['@list']) {|stmt| yield stmt}
-
-                # Append a triple composed of subject, prediate, and object to results and add all triples from list_results to results.
-                yield RDF::Statement.new(subject, predicate, object)
-              else
-                # Otherwise, item is a value object or a node definition. Generate object as the result of the Object Converstion algorithm passing item.
-                object = parse_object(item)
-                debug("graph_to_rdf")  {"object: #{object.to_ntriples rescue 'malformed rdf'}"}
-                # Append a triple composed of subject, prediate, and literal to results.
-                yield RDF::Statement.new(subject, predicate, object)
-              end
-            end
-          end
-        end
-      end
-    end
-
-    ##
-    # Parse an item, either a value object or a node definition
-    # @param [Hash] item
-    # @return [RDF::Value]
-    def parse_object(item)
-      if item.has_key?('@value')
-        # Otherwise, if element is a JSON object that contains the key @value
-        # Initialize value to the value associated with the @value key in element. Initialize datatype to the value associated with the @type key in element, or null if element does not contain that key.
+    # @return RDF::Resource the subject of this item
+    def item_to_rdf(item, graph_name: nil, &block)
+      # Just return value object as Term
+      if value?(item)
         value, datatype = item.fetch('@value'), item.fetch('@type', nil)
 
         case value
@@ -75,7 +21,7 @@ module JSON::LD
           # If value is true or false, then set value its canonical lexical form as defined in the section Data Round Tripping. If datatype is null, set it to xsd:boolean.
           value = value.to_s
           datatype ||= RDF::XSD.boolean.to_s
-        when Float, Fixnum
+        when Integer, Float, Fixnum
           # Otherwise, if value is a number, then set value to its canonical lexical form as defined in the section Data Round Tripping. If datatype is null, set it to either xsd:integer or xsd:double, depending on if the value contains a fractional and/or an exponential component.
           lit = RDF::Literal.new(value, canonicalize: true)
           value = lit.to_s
@@ -88,13 +34,77 @@ module JSON::LD
                   
         # Initialize literal as an RDF literal using value and datatype. If element has the key @language and datatype is xsd:string, then add the value associated with the @language key as the language of the object.
         language = item.fetch('@language', nil)
-        RDF::Literal.new(value, datatype: datatype, language: language)
-      else
-        # Otherwise, value must be a node definition containing only @id whos value is an IRI or Blank Node identifier
-        raise "Expected node reference, got #{item.inspect}" unless item.keys == %w(@id)
-        # Return value associated with @id as an IRI or Blank node
-        as_resource(item['@id'])
+        return RDF::Literal.new(value, datatype: datatype, language: language)
       end
+
+      subject = item['@id'] ? as_resource(item['@id']) : node
+      debug("item_to_rdf")  {"subject: #{subject.to_ntriples rescue 'malformed rdf'}"}
+      item.each do |property, values|
+        case property
+        when '@type'
+          # If property is @type, construct triple as an RDF Triple composed of id, rdf:type, and object from values where id and object are represented either as IRIs or Blank Nodes
+          values.each do |v|
+            object = as_resource(v)
+            debug("item_to_rdf")  {"type: #{object.to_ntriples rescue 'malformed rdf'}"}
+            yield RDF::Statement(subject, RDF.type, object, graph_name: graph_name)
+          end
+        when '@graph'
+          values = [values].compact unless values.is_a?(Array)
+          values.each do |nd|
+            item_to_rdf(nd, graph_name: subject, &block)
+          end
+        when '@reverse'
+          raise "Huh?" unless values.is_a?(Hash)
+          values.each do |prop, vv|
+            predicate = as_resource(prop)
+            debug("item_to_rdf")  {"@reverse predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
+            # For each item in values
+            vv.each do |v|
+              if list?(v)
+                debug("item_to_rdf")  {"list: #{v.inspect}"}
+                # If item is a list object, initialize list_results as an empty array, and object to the result of the List Conversion algorithm, passing the value associated with the @list key from item and list_results.
+                object = parse_list(v['@list'], graph_name: graph_name, &block)
+
+                # Append a triple composed of object, prediate, and object to results and add all triples from list_results to results.
+                yield RDF::Statement(object, predicate, subject, graph_name: graph_name)
+              else
+                # Otherwise, item is a value object or a node definition. Generate object as the result of the Object Converstion algorithm passing item.
+                object = item_to_rdf(v, graph_name: graph_name, &block)
+                debug("item_to_rdf")  {"subject: #{object.to_ntriples rescue 'malformed rdf'}"}
+                # yield subject, prediate, and literal to results.
+                yield RDF::Statement(object, predicate, subject, graph_name: graph_name)
+              end
+            end
+          end
+        when /^@/
+          # Otherwise, if @type is any other keyword, skip to the next property-values pair
+        else
+          # Otherwise, property is an IRI or Blank Node identifier
+          # Initialize predicate from  property as an IRI or Blank node
+          predicate = as_resource(property)
+          debug("item_to_rdf")  {"predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
+
+          # For each item in values
+          values.each do |v|
+            if list?(v)
+              debug("item_to_rdf")  {"list: #{v.inspect}"}
+              # If item is a list object, initialize list_results as an empty array, and object to the result of the List Conversion algorithm, passing the value associated with the @list key from item and list_results.
+              object = parse_list(v['@list'], graph_name: graph_name, &block)
+
+              # Append a triple composed of subject, prediate, and object to results and add all triples from list_results to results.
+              yield RDF::Statement(subject, predicate, object, graph_name: graph_name)
+            else
+              # Otherwise, item is a value object or a node definition. Generate object as the result of the Object Converstion algorithm passing item.
+              object = item_to_rdf(v, graph_name: graph_name, &block)
+              debug("item_to_rdf")  {"object: #{object.to_ntriples rescue 'malformed rdf'}"}
+              # yield subject, prediate, and literal to results.
+              yield RDF::Statement(subject, predicate, object, graph_name: graph_name)
+            end
+          end
+        end
+      end
+
+      subject
     end
 
     ##
@@ -106,7 +116,7 @@ module JSON::LD
     # @yieldparam [RDF::Resource] statement
     # @return [Array<RDF::Statement>]
     #   Statements for each item in the list
-    def parse_list(list)
+    def parse_list(list, graph_name: nil, &block)
       debug('parse_list') {"list: #{list.inspect}"}
 
       last = list.pop
@@ -114,16 +124,16 @@ module JSON::LD
 
       list.each do |list_item|
         # Set first to the result of the Object Converstion algorithm passing item.
-        object = parse_object(list_item)
-        yield RDF::Statement.new(first_bnode, RDF.first, object)
+        object = item_to_rdf(list_item, graph_name: graph_name, &block)
+        yield RDF::Statement(first_bnode, RDF.first, object, graph_name: graph_name)
         rest_bnode = node
-        yield RDF::Statement.new(first_bnode, RDF.rest, rest_bnode)
+        yield RDF::Statement(first_bnode, RDF.rest, rest_bnode, graph_name: graph_name)
         first_bnode = rest_bnode
       end
       if last
-        object = parse_object(last)
-        yield RDF::Statement.new(first_bnode, RDF.first, object)
-        yield RDF::Statement.new(first_bnode, RDF.rest, RDF.nil)
+        object = item_to_rdf(last, graph_name: graph_name, &block)
+        yield RDF::Statement(first_bnode, RDF.first, object, graph_name: graph_name)
+        yield RDF::Statement(first_bnode, RDF.rest, RDF.nil, graph_name: graph_name)
       end
       result
     end

data/spec/spec_helper.rb

@@ -15,14 +15,17 @@ require 'yaml'
 require 'restclient/components'
 require 'rack/cache'
 require 'matchers'
-require 'simplecov'
-require 'coveralls'
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-]
-SimpleCov.start do
-  add_filter "/spec/"
+begin
+  require 'simplecov'
+  require 'coveralls'
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ])
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+rescue LoadError
 end
 
 require 'json/ld'

data/spec/suite_helper.rb

@@ -4,11 +4,9 @@ require 'support/extensions'
 module Fixtures
   module SuiteTest
     SUITE = RDF::URI("http://json-ld.org/test-suite/")
-    #SUITE = RDF::URI("http://localhost/~gregg/json-ld.org/test-suite/")
 
     class Manifest < JSON::LD::Resource
       def self.open(file)
-        #puts "open: #{file}"
         Fixtures::SuiteTest.documentLoader(file) do |remote|
           json = JSON.parse(remote.document)
           if block_given?
@@ -109,21 +107,26 @@ module Fixtures
             when "jld:FrameTest"
               JSON::LD::API.frame(input_loc, frame_loc, options.merge(debug: debug))
             when "jld:FromRDFTest"
-              repo = RDF::Repository.load(input_loc, format: :nquads)
+              # Use an array, to preserve input order
+              repo = RDF::NQuads::Reader.open(input_loc) do |reader|
+                reader.each_statement.to_a
+              end.extend(RDF::Enumerable)
               @debug << "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
               JSON::LD::API.fromRdf(repo, options.merge(debug: debug))
             when "jld:ToRDFTest"
-              JSON::LD::API.toRdf(input_loc, options.merge(debug: debug)).map do |statement|
-                to_quad(statement)
+              repo = RDF::Repository.new
+              JSON::LD::API.toRdf(input_loc, options.merge(debug: debug)) do |statement|
+                repo << statement
               end
+              repo
             else
               fail("Unknown test type: #{testType}")
             end
             if evaluationTest?
               if testType == "jld:ToRDFTest"
-                expected = expect
+                expected = RDF::Repository.new << RDF::NQuads::Reader.new(expect)
                 rspec_example.instance_eval {
-                  expect(result.sort.join("")).to produce(expected, debug)
+                  expect(result).to be_equivalent_graph(expected, debug)
                 }
               else
                 expected = JSON.load(expect)
@@ -161,9 +164,7 @@ module Fixtures
                   debug << "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
                   JSON::LD::API.fromRdf(repo, options.merge(debug: debug))
                 when "jld:ToRDFTest"
-                  JSON::LD::API.toRdf(t.input_loc, options.merge(debug: debug)).map do |statement|
-                    t.to_quad(statement)
-                  end
+                  JSON::LD::API.toRdf(t.input_loc, options.merge(debug: debug)) {}
                 else
                   success("Unknown test type: #{testType}")
                 end

data/spec/suite_to_rdf_spec.rb

@@ -9,6 +9,9 @@ describe JSON::LD do
     describe m.name do
       m.entries.each do |t|
         specify "#{t.property('input')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
+          skip "Native value fidelity" if %w(toRdf-0035-in.jsonld).include?(t.property('input'))
+          pending "Generalized RDF" if %w(toRdf-0118-in.jsonld).include?(t.property('input'))
+          pending "Blank nodes with reverse properties" if %w(toRdf-0119-in.jsonld).include?(t.property('input'))
           t.run self
         end
       end

data/spec/writer_spec.rb

@@ -195,6 +195,7 @@ describe JSON::LD::Writer do
         t.debug = ["test: #{t.inspect}", "source: #{t.input}"]
         specify "#{t.property('input')}: #{t.name}" do
           pending "Shared list BNode in different graphs" if t.property('input').include?("fromRdf-0021")
+          pending "graph comparison issue" if t.property('input').include?("fromRdf-0008")
           repo = RDF::Repository.load(t.input_loc, format: :nquads)
           jsonld = JSON::LD::Writer.buffer(debug: t.debug) do |writer|
             writer << repo

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json-ld
 version: !ruby/object:Gem::Version
-  version: 1.99.0
+  version: 1.99.1
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-14 00:00:00.000000000 Z
+date: 2016-02-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -212,14 +212,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.4'
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
@@ -361,7 +361,7 @@ files:
 - spec/writer_spec.rb
 homepage: http://github.com/ruby-rdf/json-ld
 licenses:
-- Public Domain
+- Unlicense
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -371,7 +371,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -379,7 +379,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: json-ld
-rubygems_version: 2.4.5.1
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: JSON-LD reader/writer for Ruby.