json-ld 1.99.2 → 2.0.0.beta1

data/lib/json/ld/to_rdf.rb

@@ -6,14 +6,68 @@ module JSON::LD
     include Utils
 
     ##
-    # @param [Hash{String => Object}] node
-    # @param [RDF::Resource] graph_name
+    #
+    # @param [Hash{String => Hash}] active_graph
+    #   A hash of IRI to Node definitions
     # @yield statement
     # @yieldparam [RDF::Statement] statement
-    # @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)
+    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.
         value, datatype = item.fetch('@value'), item.fetch('@type', nil)
 
         case value
@@ -21,7 +75,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 Integer, Float, Fixnum
+        when 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
@@ -34,77 +88,13 @@ 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)
-        return RDF::Literal.new(value, datatype: datatype, language: language)
+        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'])
       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
 
     ##
@@ -116,24 +106,24 @@ module JSON::LD
     # @yieldparam [RDF::Resource] statement
     # @return [Array<RDF::Statement>]
     #   Statements for each item in the list
-    def parse_list(list, graph_name: nil, &block)
-      debug('parse_list') {"list: #{list.inspect}"}
+    def parse_list(list)
+      log_debug('parse_list') {"list: #{list.inspect}"}
 
       last = list.pop
       result = first_bnode = last ? node : RDF.nil
 
       list.each do |list_item|
         # Set first to the result of the Object Converstion algorithm passing item.
-        object = item_to_rdf(list_item, graph_name: graph_name, &block)
-        yield RDF::Statement(first_bnode, RDF.first, object, graph_name: graph_name)
+        object = parse_object(list_item)
+        yield RDF::Statement(first_bnode, RDF.first, object)
         rest_bnode = node
-        yield RDF::Statement(first_bnode, RDF.rest, rest_bnode, graph_name: graph_name)
+        yield RDF::Statement(first_bnode, RDF.rest, rest_bnode)
         first_bnode = rest_bnode
       end
       if last
-        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)
+        object = parse_object(last)
+        yield RDF::Statement(first_bnode, RDF.first, object)
+        yield RDF::Statement(first_bnode, RDF.rest, RDF.nil)
       end
       result
     end

data/lib/json/ld/utils.rb

@@ -70,7 +70,7 @@ module JSON::LD
     def as_resource(id, base = nil)
       @nodes ||= {} # Re-use BNodes
       if id[0,2] == '_:'
-        (@nodes[id] ||= RDF::Node.new(namer.get_sym(id)))
+        (@nodes[id] ||= RDF::Node.new(id[2..-1]))
       elsif base
         base.join(id)
       else
@@ -207,35 +207,6 @@ module JSON::LD
         end
       end
     end
-
-    # Add debug event to debug array, if specified
-    #
-    #   param [String] message
-    #   yieldreturn [String] appended to message, to allow for lazy-evaluation of message
-    def debug(*args)
-      return unless ::JSON::LD.debug? || @options[:debug]
-      depth = @depth || 0
-      list = args
-      list << yield if block_given?
-      message = " " * depth * 2 + list.join(": ")
-      case @options[:debug]
-      when Array
-        @options[:debug] << message
-      when TrueClass
-        $stderr.puts message
-      else
-        $stderr.puts message if JSON::LD::debug?
-      end
-    end
-
-    # Increase depth around a method invocation
-    def depth(options = {})
-      old_depth = @depth || 0
-      @depth = (options[:depth] || old_depth) + 1
-      yield
-    ensure
-      @depth = old_depth
-    end
   end
 
   ##

data/lib/json/ld/writer.rb

@@ -54,6 +54,7 @@ module JSON::LD
   class Writer < RDF::Writer
     include StreamingWriter
     include Utils
+    include RDF::Util::Logger
     format Format
 
     # @!attribute [r] graph
@@ -64,6 +65,39 @@ module JSON::LD
     # @return [Context] context used to load and administer contexts
     attr_reader :context
 
+    ##
+    # JSON-LD Writer options
+    # @see http://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Writer#options-class_method
+    def self.options
+      super + [
+        RDF::CLI::Option.new(
+          symbol: :compactArrays,
+          datatype: TrueClass,
+          on: ["--compact-arrays"],
+          description: "Replaces arrays with just one element with that element during compaction.") {true},
+        RDF::CLI::Option.new(
+          symbol: :context,
+          datatype: RDF::URI,
+          on: ["--context CONTEXT"],
+          description: "Context to use when serializing. Constructed context for native serialization.") {|arg| RDF::URI(arg)},
+        RDF::CLI::Option.new(
+          symbol: :frame,
+          datatype: RDF::URI,
+          on: ["--frame FRAME"],
+          description: "Frame to use when serializing.") {|arg| RDF::URI(arg)},
+        RDF::CLI::Option.new(
+          symbol: :stream,
+          datatype: TrueClass,
+          on: ["--stream"],
+          description: "Do not attempt to optimize graph presentation, suitable for streaming large graphs.") {true},
+        RDF::CLI::Option.new(
+          symbol: :useRdfType,
+          datatype: TrueClass,
+          on: ["--use-rdf-type"],
+          description: "Treat `rdf:type` like a normal property instead of using `@type`.") {true},
+      ]
+    end
+
     ##
     # Initializes the RDF-LD writer instance.
     #
@@ -97,7 +131,6 @@ module JSON::LD
       options[:base] ||= options[:base_uri] if options.has_key?(:base_uri)
       super do
         @repo = RDF::Repository.new
-        @debug = @options[:debug]
 
         if block_given?
           case block.arity
@@ -108,42 +141,39 @@ module JSON::LD
       end
     end
 
-    ##
-    # Adds a statement to be serialized
-    # @param  [RDF::Statement] statement
-    # @return [void]
-    def write_statement(statement)
-      case
-      when @options[:stream]
-        stream_statement(statement)
-      else
-        # Add to repo and output in epilogue
-        @repo.insert(statement)
-      end
-    end
-
     ##
     # Addes a triple to be serialized
     # @param  [RDF::Resource] subject
     # @param  [RDF::URI]      predicate
     # @param  [RDF::Value]    object
     # @return [void]
-    # @raise  [NotImplementedError] unless implemented in subclass
     # @abstract
     def write_triple(subject, predicate, object)
-      write_statement(Statement.new(subject, predicate, object))
+      write_quad(subject, predicate, object, nil)
+    end
+
+    ##
+    # Outputs the N-Quads representation of a statement.
+    #
+    # @param  [RDF::Resource] subject
+    # @param  [RDF::URI]      predicate
+    # @param  [RDF::Term]     object
+    # @return [void]
+    def write_quad(subject, predicate, object, graph_name)
+      statement = RDF::Statement.new(subject, predicate, object, graph_name: graph_name)
+      if @options[:stream]
+        stream_statement(statement)
+      else
+        @repo.insert(statement)
+      end
     end
 
     ##
     # Necessary for streaming
     # @return [void] `self`
     def write_prologue
-      case
-      when @options[:stream]
-        stream_prologue
-      else
-        super
-      end
+      stream_prologue if @options[:stream]
+      super
     end
 
     ##
@@ -155,40 +185,45 @@ module JSON::LD
     # @return [void]
     # @see    #write_triple
     def write_epilogue
-      return stream_epilogue if @options[:stream]
+      if @options[:stream]
+        stream_epilogue
+      else
 
-      debug("writer") { "serialize #{@repo.count} statements, #{@options.inspect}"}
-      result = API.fromRdf(@repo, @options)
+        log_debug("writer") { "serialize #{@repo.count} statements, #{@options.inspect}"}
+        result = API.fromRdf(@repo, @options)
 
-      # If we were provided a context, or prefixes, use them to compact the output
-      context = RDF::Util::File.open_file(@options[:context]) if @options[:context].is_a?(String)
-      context ||= @options[:context]
-      context ||= if @options[:prefixes] || @options[:language] || @options[:standard_prefixes]
-        ctx = Context.new(@options)
-        ctx.language = @options[:language] if @options[:language]
-        @options[:prefixes].each do |prefix, iri|
-          ctx.set_mapping(prefix, iri) if prefix && iri
-        end if @options[:prefixes]
-        ctx
-      end
+        # If we were provided a context, or prefixes, use them to compact the output
+        context = RDF::Util::File.open_file(@options[:context]) if @options[:context].is_a?(String)
+        context ||= @options[:context]
+        context ||= if @options[:prefixes] || @options[:language] || @options[:standard_prefixes]
+          ctx = Context.new(@options)
+          ctx.language = @options[:language] if @options[:language]
+          @options[:prefixes].each do |prefix, iri|
+            ctx.set_mapping(prefix, iri) if prefix && iri
+          end if @options[:prefixes]
+          ctx
+        end
 
-      # Rename BNodes to uniquify them, if necessary
-      if options[:unique_bnodes]
-        result = API.flatten(result, context, @options)
-      end
+        # Rename BNodes to uniquify them, if necessary
+        if options[:unique_bnodes]
+          result = API.flatten(result, context, @options)
+        end
+
+        frame = RDF::Util::File.open_file(@options[:frame]) if @options[:frame].is_a?(String)
+        if frame ||= @options[:frame]
+          # Perform framing, if given a frame
+          log_debug("writer") { "frame result"}
+          result = API.frame(result, frame, @options)
+        elsif context
+          # Perform compaction, if we have a context
+          log_debug("writer") { "compact result"}
+          result = API.compact(result, context,  @options)
+        end
 
-      frame = RDF::Util::File.open_file(@options[:frame]) if @options[:frame].is_a?(String)
-      if frame ||= @options[:frame]
-        # Perform framing, if given a frame
-        debug("writer") { "frame result"}
-        result = API.frame(result, frame, @options)
-      elsif context
-        # Perform compaction, if we have a context
-        debug("writer") { "compact result"}
-        result = API.compact(result, context,  @options)
+        @output.write(result.to_json(JSON_STATE))
       end
 
-      @output.write(result.to_json(JSON_STATE))
+      super
     end
   end
 end

data/spec/api_spec.rb

@@ -3,7 +3,7 @@ $:.unshift "."
 require 'spec_helper'
 
 describe JSON::LD::API do
-  before(:each) { @debug = []}
+  let(:logger) {RDF::Spec.logger}
 
   describe "#initialize" do
     context "with string input" do
@@ -78,24 +78,24 @@ describe JSON::LD::API do
       
           context test, skip: ("Not supported in JRuby" if RUBY_ENGINE == "jruby" && %w(oj yajl).include?(adapter.to_s)) do
             it "expands" do
-              options = {debug: @debug, adapter: adapter}
+              options = {logger: logger, adapter: adapter}
               options[:expandContext] = File.open(context) if context
               jld = described_class.expand(File.open(filename), options)
-              expect(jld).to produce(JSON.load(File.open(expanded)), @debug)
+              expect(jld).to produce(JSON.load(File.open(expanded)), logger)
             end if File.exist?(expanded)
         
             it "compacts" do
-              jld = described_class.compact(File.open(filename), File.open(context), adapter: adapter, debug: @debug)
-              expect(jld).to produce(JSON.load(File.open(compacted)), @debug)
+              jld = described_class.compact(File.open(filename), File.open(context), adapter: adapter, logger: logger)
+              expect(jld).to produce(JSON.load(File.open(compacted)), logger)
             end if File.exist?(compacted) && File.exist?(context)
         
             it "frame" do
-              jld = described_class.frame(File.open(filename), File.open(frame), adapter: adapter, debug: @debug)
-              expect(jld).to produce(JSON.load(File.open(framed)), @debug)
+              jld = described_class.frame(File.open(filename), File.open(frame), adapter: adapter, logger: logger)
+              expect(jld).to produce(JSON.load(File.open(framed)), logger)
             end if File.exist?(framed) && File.exist?(frame)
 
             it "toRdf" do
-              expect(RDF::Repository.load(filename, format: :jsonld, adapter: adapter, debug: @debug)).to be_equivalent_graph(RDF::Repository.load(ttl), trace: @debug)
+              expect(RDF::Repository.load(filename, format: :jsonld, adapter: adapter, logger: logger)).to be_equivalent_graph(RDF::Repository.load(ttl), logger: logger)
             end if File.exist?(ttl)
           end
         end