json-ld 2.0.0.beta1 → 2.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 41122ee834694585f5bccd788b5310ca40ece180
-  data.tar.gz: 7c6ab81c44cdc21260b6dc0b2c9882c96d3dd0c0
+  metadata.gz: 5adc54c6221f35206e44c2d599acc5bdf40431c5
+  data.tar.gz: 484e28238ca6b1615943d1b3040fa08cf9b077c1
 SHA512:
-  metadata.gz: 3fecd04504e2bc9b4a7c40cb867c95c8b0aec0afc560e928bf330642ac397571bad7bc6b61cdcd7e1deae115a859346aa27ef07e3aab079c19736e4dbc2a3b96
-  data.tar.gz: 52bb0c863bd72dbd28fa02caa1b2eeb93c263b9310f09a6ca2e9745ad4df3dccb6c013d77255a6d4467ec2a7dcf275297605dd48549bfd7c514ed432507f79b7
+  metadata.gz: 9d268dcf9996b5cb83bf2a775c96c04a2cca8afd6901fdf7b40815b2a654edc3e032d528bc4bc59c712c11fa0d78c6aabc08ddd8010f42abc9c76f089ccf5aed
+  data.tar.gz: a283566902b6d1896f2685c06de158d35da2a94317afaf942ebb6ee4714eb9d7d4eb1f65e2538fc381a278e457a0d99b21640bc7ab9e3a2fc90bb69799c13516

data/VERSION

@@ -1 +1 @@
-2.0.0.beta1
+2.0.0.beta2

data/lib/json/ld/api.rb

@@ -414,22 +414,11 @@ module JSON::LD
         #    This removes any existing context to allow the given context to be cleanly applied.
         log_debug(".toRdf") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
 
-        # Generate _nodeMap_
-        graphs = {'@default' => {}}
-        create_node_map(expanded_input, graphs)
-        log_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'
-          log_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
-            log_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
@@ -446,12 +435,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/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)
-      log_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)
-        log_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)
-              log_debug("graph_to_rdf")  {"type: #{object.to_ntriples rescue 'malformed rdf'}"}
-              yield RDF::Statement(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)
-            log_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')
-                log_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(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)
-                log_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(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
+      log_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)
+            log_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)
+            log_debug("item_to_rdf")  {"@reverse predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
+            # For each item in values
+            vv.each do |v|
+              if list?(v)
+                log_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)
+                log_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)
+          log_debug("item_to_rdf")  {"predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
+
+          # For each item in values
+          values.each do |v|
+            if list?(v)
+              log_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)
+              log_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)
       log_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(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(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(first_bnode, RDF.first, object)
-        yield RDF::Statement(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/lib/json/ld/writer.rb

@@ -130,6 +130,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
+        log_statistics.clear  # FIXME: shouldn't be necessary
         @repo = RDF::Repository.new
 
         if block_given?

data/spec/suite_helper.rb

@@ -115,17 +115,19 @@ module Fixtures
               logger.info "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
               JSON::LD::API.fromRdf(repo, options.merge(logger: logger))
             when "jld:ToRDFTest"
-              JSON::LD::API.toRdf(input_loc, options.merge(logger: logger)).map do |statement|
-                to_quad(statement)
+              repo = RDF::Repository.new
+              JSON::LD::API.toRdf(input_loc, options.merge(logger: logger)) 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, logger)
+                  expect(result).to be_equivalent_graph(expected, logger)
                 }
               else
                 expected = JSON.load(expect)
@@ -163,9 +165,7 @@ module Fixtures
                   logger.info "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
                   JSON::LD::API.fromRdf(repo, options.merge(logger: logger))
                 when "jld:ToRDFTest"
-                  JSON::LD::API.toRdf(t.input_loc, options.merge(logger: logger)).map do |statement|
-                    t.to_quad(statement)
-                  end
+                  JSON::LD::API.toRdf(t.input_loc, options.merge(logger: logger)) {}
                 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

@@ -9,7 +9,7 @@ describe JSON::LD::Writer do
   after(:each) {|example| puts logger.to_s if example.exception}
 
   it_behaves_like 'an RDF::Writer' do
-    let(:writer) {JSON::LD::Writer.new(StringIO.new(""))}
+    let(:writer) {JSON::LD::Writer.new(StringIO.new, logger: logger)}
   end
 
   describe ".for" do
@@ -196,11 +196,14 @@ describe JSON::LD::Writer do
     describe m.name do
       m.entries.each do |t|
         next unless t.positiveTest? && !t.property('input').include?('0016')
-        t.debug = ["test: #{t.inspect}", "source: #{t.input}"]
         specify "#{t.property('input')}: #{t.name}" do
+          logger.info "test: #{t.inspect}"
+          logger.info "source: #{t.input}"
+          t.logger = logger
           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|
+          jsonld = JSON::LD::Writer.buffer(logger: t.logger) do |writer|
             writer << repo
           end
 
@@ -221,7 +224,7 @@ describe JSON::LD::Writer do
   # Serialize ntstr to a string and compare against regexps
   def serialize(ntstr, options = {})
     g = ntstr.is_a?(String) ? parse(ntstr, options) : ntstr
-    logger.info g.dump(:ttl)
+    #logger.info g.dump(:ttl)
     result = JSON::LD::Writer.buffer(options.merge(logger: logger)) do |writer|
       writer << g
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json-ld
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta1
+  version: 2.0.0.beta2
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-22 00:00:00.000000000 Z
+date: 2016-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -420,7 +420,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: json-ld
-rubygems_version: 2.5.1
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: JSON-LD reader/writer for Ruby.