json-ld 1.99.2 → 2.0.0.beta1

data/lib/json/ld/expand.rb

@@ -16,11 +16,11 @@ module JSON::LD
     # @return [Array, Hash]
     def expand(input, active_property, context, options = {})
       options = {ordered: true}.merge!(options)
-      debug("expand") {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
+      log_debug("expand") {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
       result = case input
       when Array
         # If element is an array,
-        depth do
+        log_depth do
           is_list = context.container(active_property) == '@list'
           value = input.map do |v|
             # Initialize expanded item to the result of using this algorithm recursively, passing active context, active property, and item as element.
@@ -39,26 +39,26 @@ module JSON::LD
         # If element contains the key @context, set active context to the result of the Context Processing algorithm, passing active context and the value of the @context key as local context.
         if input.has_key?('@context')
           context = context.parse(input.delete('@context'))
-          debug("expand") {"context: #{context.inspect}"}
+          log_debug("expand") {"context: #{context.inspect}"}
         end
 
-        depth do
+        log_depth do
           output_object = {}
           # Then, proceed and process each property and value in element as follows:
           keys = options[:ordered] ? input.keys.kw_sort : input.keys
           keys.each do |key|
             # For each key and value in element, ordered lexicographically by key:
             value = input[key]
-            expanded_property = context.expand_iri(key, vocab: true, depth: @depth)
+            expanded_property = context.expand_iri(key, vocab: true, log_depth: @options[:log_depth])
 
             # If expanded property is null or it neither contains a colon (:) nor it is a keyword, drop key by continuing to the next key.
             next if expanded_property.is_a?(RDF::URI) && expanded_property.relative?
             expanded_property = expanded_property.to_s if expanded_property.is_a?(RDF::Resource)
 
-            debug("expand property") {"ap: #{active_property.inspect}, expanded: #{expanded_property.inspect}, value: #{value.inspect}"}
+            log_debug("expand property") {"ap: #{active_property.inspect}, expanded: #{expanded_property.inspect}, value: #{value.inspect}"}
 
             if expanded_property.nil?
-              debug(" => ") {"skip nil property"}
+              log_debug(" => ") {"skip nil property"}
               next
             end
 
@@ -78,21 +78,21 @@ module JSON::LD
                       "value of @id must be a string: #{value.inspect}" unless value.is_a?(String)
 
                 # Otherwise, set expanded value to the result of using the IRI Expansion algorithm, passing active context, value, and true for document relative.
-                context.expand_iri(value, documentRelative: true, depth: @depth).to_s
+                context.expand_iri(value, documentRelative: true, log_depth: @options[:log_depth]).to_s
               when '@type'
                 # If expanded property is @type and value is neither a string nor an array of strings, an invalid type value error has been detected and processing is aborted. Otherwise, set expanded value to the result of using the IRI Expansion algorithm, passing active context, true for vocab, and true for document relative to expand the value or each of its items.
-                debug("@type") {"value: #{value.inspect}"}
+                log_debug("@type") {"value: #{value.inspect}"}
                 case value
                 when Array
-                  depth do
+                  log_depth do
                     value.map do |v|
                       raise JsonLdError::InvalidTypeValue,
                             "@type value must be a string or array of strings: #{v.inspect}" unless v.is_a?(String)
-                      context.expand_iri(v, vocab: true, documentRelative: true, quiet: true, depth: @depth).to_s
+                      context.expand_iri(v, vocab: true, documentRelative: true, quiet: true, log_depth: @options[:log_depth]).to_s
                     end
                   end
                 when String
-                  context.expand_iri(value, vocab: true, documentRelative: true, quiet: true, depth: @depth).to_s
+                  context.expand_iri(value, vocab: true, documentRelative: true, quiet: true, log_depth: @options[:log_depth]).to_s
                 when Hash
                   # For framing
                   raise JsonLdError::InvalidTypeValue,
@@ -104,7 +104,7 @@ module JSON::LD
                 end
               when '@graph'
                 # If expanded property is @graph, set expanded value to the result of using this algorithm recursively passing active context, @graph for active property, and value for element.
-                depth { expand(value, '@graph', context, options) }
+                log_depth { expand(value, '@graph', context, options) }
               when '@value'
                 # If expanded property is @value and value is not a scalar or null, an invalid value object value error has been detected and processing is aborted. Otherwise, set expanded value to value. If expanded value is null, set the @value member of result to null and continue with the next key from element. Null values need to be preserved in this case as the meaning of an @type member depends on the existence of an @value member.
                 raise JsonLdError::InvalidValueObjectValue,
@@ -131,7 +131,7 @@ module JSON::LD
                 next if (active_property || '@graph') == '@graph'
 
                 # Otherwise, initialize expanded value to the result of using this algorithm recursively passing active context, active property, and value for element.
-                value = depth { expand(value, active_property, context, options) }
+                value = log_depth { expand(value, active_property, context, options) }
 
                 # Spec FIXME: need to be sure that result is an array
                 value = [value] unless value.is_a?(Array)
@@ -144,7 +144,7 @@ module JSON::LD
                 value
               when '@set'
                 # If expanded property is @set, set expanded value to the result of using this algorithm recursively, passing active context, active property, and value for element.
-                depth { expand(value, active_property, context, options) }
+                log_depth { expand(value, active_property, context, options) }
               when '@reverse'
                 # If expanded property is @reverse and value is not a JSON object, an invalid @reverse value error has been detected and processing is aborted.
                 raise JsonLdError::InvalidReverseValue,
@@ -152,11 +152,11 @@ module JSON::LD
 
                 # Otherwise
                 # Initialize expanded value to the result of using this algorithm recursively, passing active context, @reverse as active property, and value as element.
-                value = depth { expand(value, '@reverse', context, options) }
+                value = log_depth { expand(value, '@reverse', context, options) }
 
                 # If expanded value contains an @reverse member, i.e., properties that are reversed twice, execute for each of its property and item the following steps:
                 if value.has_key?('@reverse')
-                  debug("@reverse") {"double reverse: #{value.inspect}"}
+                  log_debug("@reverse") {"double reverse: #{value.inspect}"}
                   value['@reverse'].each do |property, item|
                     # If result does not have a property member, create one and set its value to an empty array.
                     # Append item to the value of the property member of result.
@@ -184,14 +184,14 @@ module JSON::LD
                 next
               when '@explicit', '@default', '@embed', '@explicit', '@omitDefault', '@preserve', '@requireAll'
                 # Framing keywords
-                depth { [expand(value, expanded_property, context, options)].flatten }
+                log_depth { [expand(value, expanded_property, context, options)].flatten }
               else
                 # Skip unknown keyword
                 next
               end
 
               # Unless expanded value is null, set the expanded property member of result to expanded value.
-              debug("expand #{expanded_property}") { expanded_value.inspect}
+              log_debug("expand #{expanded_property}") { expanded_value.inspect}
               output_object[expanded_property] = expanded_value unless expanded_value.nil?
               next
             end
@@ -229,7 +229,7 @@ module JSON::LD
               keys = options[:ordered] ? value.keys.sort : value.keys
               keys.each do |k|
                 # Initialize index value to the result of using this algorithm recursively, passing active context, key as active property, and index value as element.
-                index_value = depth { expand([value[k]].flatten, key, context, options) }
+                index_value = log_depth { expand([value[k]].flatten, key, context, options) }
                 index_value.each do |item|
                   item['@index'] ||= k
                   ary << item
@@ -238,22 +238,22 @@ module JSON::LD
               ary
             else
               # Otherwise, initialize expanded value to the result of using this algorithm recursively, passing active context, key for active property, and value for element.
-              depth { expand(value, key, context, options) }
+              log_depth { expand(value, key, context, options) }
             end
 
             # If expanded value is null, ignore key by continuing to the next key from element.
             if expanded_value.nil?
-              debug(" => skip nil value")
+              log_debug(" => skip nil value")
               next
             end
-            debug {" => #{expanded_value.inspect}"}
+            log_debug {" => #{expanded_value.inspect}"}
 
             # If the container mapping associated to key in active context is @list and expanded value is not already a list object, convert expanded value to a list object by first setting it to an array containing only expanded value if it is not already an array, and then by setting it to a JSON object containing the key-value pair @list-expanded value.
             if context.container(key) == '@list' && !list?(expanded_value)
-              debug(" => ") { "convert #{expanded_value.inspect} to list"}
+              log_debug(" => ") { "convert #{expanded_value.inspect} to list"}
               expanded_value = {'@list' => [expanded_value].flatten}
             end
-            debug {" => #{expanded_value.inspect}"}
+            log_debug {" => #{expanded_value.inspect}"}
 
             # Otherwise, if the term definition associated to key indicates that it is a reverse property
             # Spec FIXME: this is not an otherwise.
@@ -276,7 +276,7 @@ module JSON::LD
             end
           end
 
-          debug("output object") {output_object.inspect}
+          log_debug("output object") {output_object.inspect}
 
           # If result contains the key @value:
           if value?(output_object)
@@ -298,7 +298,7 @@ module JSON::LD
               raise JsonLdError::InvalidLanguageTaggedValue,
                     "when @language is used, @value must be a string: #{@value.inspect}"
             elsif !output_object.fetch('@type', "").is_a?(String) ||
-                  !context.expand_iri(output_object.fetch('@type', ""), vocab: true, depth: @depth).is_a?(RDF::URI)
+                  !context.expand_iri(output_object.fetch('@type', ""), vocab: true, log_depth: @options[:log_depth]).is_a?(RDF::URI)
               # Otherwise, if the result has a @type member and its value is not an IRI, an invalid typed value error has been detected and processing is aborted.
               raise JsonLdError::InvalidTypedValue,
                     "value of @type must be an IRI: #{output_object['@type'].inspect}"
@@ -324,7 +324,7 @@ module JSON::LD
           if (active_property || '@graph') == '@graph' &&
             (output_object.keys.any? {|k| %w(@value @list).include?(k)} ||
              (output_object.keys - %w(@id)).empty?)
-            debug(" =>") { "empty top-level: " + output_object.inspect}
+            log_debug(" =>") { "empty top-level: " + output_object.inspect}
             return nil
           end
 
@@ -338,10 +338,10 @@ module JSON::LD
       else
         # Otherwise, unless the value is a number, expand the value according to the Value Expansion rules, passing active property.
         return nil if input.nil? || active_property.nil? || active_property == '@graph'
-        context.expand_value(active_property, input, depth: @depth)
+        context.expand_value(active_property, input, log_depth: @options[:log_depth])
       end
 
-      debug {" => #{result.inspect}"}
+      log_debug {" => #{result.inspect}"}
       result
     end
   end

data/lib/json/ld/flatten.rb

@@ -19,8 +19,8 @@ module JSON::LD
                         graph = '@default',
                         name  = nil,
                         list  = nil)
-      depth do
-        debug("node_map") {"graph: #{graph}, input: #{input.inspect}, name: #{name}"}
+      log_depth do
+        log_debug("node_map") {"graph: #{graph}, input: #{input.inspect}, name: #{name}"}
         case input
         when Array
           # If input is an array, process each entry in input recursively by passing item for input, node map, active graph, active subject, active property, and list.

data/lib/json/ld/format.rb

@@ -41,7 +41,132 @@ module JSON::LD
         # Exclude CSVW metadata
         !sample.include?("http://www.w3.org/ns/csvw")
     end
-    
+
+    ##
+    # Hash of CLI commands appropriate for this format
+    # @return [Hash{Symbol => Lambda(Array, Hash)}]
+    def self.cli_commands
+      {
+        expand: ->(files, options) do
+          out = options[:output] || $stdout
+          out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
+          options = options.merge(expandContext: options.delete(:context)) if options.has_key?(:context)
+          if options[:format] == :jsonld
+            if files.empty?
+              # If files are empty, either use options[:execute]
+              input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
+              input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
+              JSON::LD::API.expand(input, options) do |expanded|
+                out.puts expanded.to_json(JSON::LD::JSON_STATE)
+              end
+            else
+              files.each do |file|
+                JSON::LD::API.expand(file, options) do |expanded|
+                  out.puts expanded.to_json(JSON::LD::JSON_STATE)
+                end
+              end
+            end
+          else
+            # Turn RDF into JSON-LD first
+            RDF::CLI.parse(files, options) do |reader|
+              JSON::LD::API.fromRdf(reader) do |expanded|
+                out.puts expanded.to_json(JSON::LD::JSON_STATE)
+              end
+            end
+          end
+        end,
+        compact: ->(files, options) do
+          raise ArgumentError, "Compacting requires a context" unless options[:context]
+          out = options[:output] || $stdout
+          out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
+          if options[:format] == :jsonld
+            if files.empty?
+              # If files are empty, either use options[:execute]
+              input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
+              input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
+              JSON::LD::API.compact(input, options[:context], options) do |compacted|
+                out.puts compacted.to_json(JSON::LD::JSON_STATE)
+              end
+            else
+              files.each do |file|
+                JSON::LD::API.compact(file, options[:context], options) do |compacted|
+                  out.puts compacted.to_json(JSON::LD::JSON_STATE)
+                end
+              end
+            end
+          else
+            # Turn RDF into JSON-LD first
+            RDF::CLI.parse(files, options) do |reader|
+              JSON::LD::API.fromRdf(reader) do |expanded|
+                JSON::LD::API.compact(expanded, options[:context], options) do |compacted|
+                  out.puts compacted.to_json(JSON::LD::JSON_STATE)
+                end
+              end
+            end
+          end
+        end,
+        flatten: ->(files, options) do
+          out = options[:output] || $stdout
+          out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
+          if options[:format] == :jsonld
+            if files.empty?
+              # If files are empty, either use options[:execute]
+              input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
+              input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
+              JSON::LD::API.flatten(input, options[:context], options) do |flattened|
+                out.puts flattened.to_json(JSON::LD::JSON_STATE)
+              end
+            else
+              files.each do |file|
+                JSON::LD::API.flatten(file, options[:context], options) do |flattened|
+                  out.puts flattened.to_json(JSON::LD::JSON_STATE)
+                end
+              end
+            end
+          else
+            # Turn RDF into JSON-LD first
+            RDF::CLI.parse(files, options) do |reader|
+              JSON::LD::API.fromRdf(reader) do |expanded|
+                JSON::LD::API.flatten(expanded, options[:context], options) do |flattened|
+                  out.puts flattened.to_json(JSON::LD::JSON_STATE)
+                end
+              end
+            end
+          end
+        end,
+        frame: ->(files, options) do
+          raise ArgumentError, "Framing requires a frame" unless options[:frame]
+          out = options[:output] || $stdout
+          out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
+          if options[:format] == :jsonld
+            if files.empty?
+              # If files are empty, either use options[:execute]
+              input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
+              input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
+              JSON::LD::API.frame(input, options[:frame], options) do |framed|
+                out.puts framed.to_json(JSON::LD::JSON_STATE)
+              end
+            else
+              files.each do |file|
+                JSON::LD::API.frame(file, options[:frame], options) do |framed|
+                  out.puts framed.to_json(JSON::LD::JSON_STATE)
+                end
+              end
+            end
+          else
+            # Turn RDF into JSON-LD first
+            RDF::CLI.parse(files, options) do |reader|
+              JSON::LD::API.fromRdf(reader) do |expanded|
+                JSON::LD::API.frame(expanded, options[:frame], options) do |framed|
+                  out.puts framed.to_json(JSON::LD::JSON_STATE)
+                end
+              end
+            end
+          end
+        end,
+      }
+    end
+
     ##
     # Override normal symbol generation
     def self.to_sym

data/lib/json/ld/frame.rb

@@ -17,7 +17,7 @@ module JSON::LD
     #   The parent property.
     # @raise [JSON::LD::InvalidFrame]
     def frame(state, subjects, frame, options = {})
-      depth do
+      log_depth do
         parent, property = options[:parent], options[:property]
         # Validate the frame
         validate_frame(state, frame)
@@ -151,7 +151,7 @@ module JSON::LD
     # @param [Array, Hash] input
     # @return [Array, Hash]
     def cleanup_preserve(input)
-      depth do
+      log_depth do
         result = case input
         when Array
           # If, after replacement, an array contains only the value null remove the value, leaving an empty array.
@@ -337,7 +337,7 @@ module JSON::LD
       # recursively remove dependent dangling embeds
       def remove_dependents(id, embeds)
 
-        depth do
+        log_depth do
           # get embed keys as a separate array to enable deleting keys in map
           embeds.each do |id_dep, e|
             p = e.fetch(:parent, {}) if e.is_a?(Hash)

data/lib/json/ld/from_rdf.rb

@@ -22,7 +22,7 @@ module JSON::LD
 
       # For each triple in input
       input.each do |statement|
-        debug("statement") { statement.to_nquads.chomp}
+        log_debug("statement") { statement.to_nquads.chomp}
 
         name = statement.graph_name ? ec.expand_iri(statement.graph_name).to_s : '@default'
         
@@ -71,7 +71,7 @@ module JSON::LD
           list, list_nodes = [], []
 
           # If property equals rdf:rest, the value associated to the usages member of node has exactly 1 entry, node has a rdf:first and rdf:rest property, both of which have as value an array consisting of a single element, and node has no other members apart from an optional @type member whose value is an array with a single item equal to rdf:List, node represents a well-formed list node. Continue with the following steps:
-          debug("list element?") {node.to_json(JSON_STATE) rescue 'malformed json'}
+          log_debug("list element?") {node.to_json(JSON_STATE) rescue 'malformed json'}
           while property == RDF.rest.to_s &&
               node_usages_map[node['@id']].uniq.length == 1 &&
               blank_node?(node) &&
@@ -118,7 +118,7 @@ module JSON::LD
         node.delete(:usages)
         result << node unless node_reference?(node)
       end
-      debug("fromRdf") {result.to_json(JSON_STATE) rescue 'malformed json'}
+      log_debug("fromRdf") {result.to_json(JSON_STATE) rescue 'malformed json'}
       result
     end
   end

data/lib/json/ld/reader.rb

@@ -7,6 +7,19 @@ module JSON::LD
   class Reader < RDF::Reader
     format Format
 
+    ##
+    # JSON-LD Reader options
+    # @see http://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Reader#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},
+      ]
+    end
+
     ##
     # Initializes the RDF/JSON reader instance.
     #
@@ -28,9 +41,6 @@ module JSON::LD
           else
             StringIO.new(input.to_s.sub(%r(\A[^{\[]*)m, '').sub(%r([^}\]]*\Z)m, ''))
           end
-        rescue JSON::ParserError => e
-          raise RDF::ReaderError, "Failed to parse input document: #{e.message}" if validate?
-          @doc = StringIO.new("{}")
         end
 
         if block_given?
@@ -47,8 +57,8 @@ module JSON::LD
     # @see   RDF::Reader#each_statement
     def each_statement(&block)
       JSON::LD::API.toRdf(@doc, @options, &block)
-    rescue ::JSON::LD::JsonLdError => e
-      raise RDF::ReaderError, e.message
+    rescue ::JSON::ParserError, ::JSON::LD::JsonLdError => e
+      log_fatal("Failed to parse input document: #{e.message}", exception: RDF::ReaderError)
     end
 
     ##

data/lib/json/ld/streaming_writer.rb

@@ -17,7 +17,7 @@ module JSON::LD
       else Context.new.parse(@options[:context])
       end
 
-      debug("prologue") {"context: #{context.inspect}"}
+      log_debug("prologue") {"context: #{context.inspect}"}
       if context
         @output.puts %({"@context": #{context.serialize['@context'].to_json}, "@graph": [)
       else
@@ -37,7 +37,7 @@ module JSON::LD
     #
     # @return [void] `self`
     def stream_statement(statement)
-      debug("ss") {"state: #{@state.inspect}, stmt: #{statement}"}
+      log_debug("ss") {"state: #{@state.inspect}, stmt: #{statement}"}
       if @current_graph != statement.graph_name
         end_graph
         start_graph(statement.graph_name)
@@ -72,7 +72,7 @@ module JSON::LD
     # Complete open statements
     # @return [void] `self`
     def stream_epilogue
-      debug("epilogue") {"state: #{@state.inspect}"}
+      log_debug("epilogue") {"state: #{@state.inspect}"}
       end_graph
       if context
         @output.puts "\n]}"
@@ -85,7 +85,7 @@ module JSON::LD
     private
     
     def start_graph(resource)
-      debug("start_graph") {"state: #{@state.inspect}, resource: #{resource}"}
+      log_debug("start_graph") {"state: #{@state.inspect}, resource: #{resource}"}
       if resource
         @output.puts(",") if [:wrote_node, :wrote_graph].include?(@state)
         @output.puts %({"@id": "#{resource}", "@graph": [)
@@ -95,7 +95,7 @@ module JSON::LD
     end
 
     def end_graph
-      debug("end_graph") {"state: #{@state.inspect}, ctx: #{@current_graph}"}
+      log_debug("end_graph") {"state: #{@state.inspect}, ctx: #{@current_graph}"}
       end_node
       if @current_graph
         @output.write %(]})
@@ -104,7 +104,7 @@ module JSON::LD
     end
 
     def end_node
-      debug("end_node") {"state: #{@state.inspect}, node: #{@current_node_def.to_json}"}
+      log_debug("end_node") {"state: #{@state.inspect}, node: #{@current_node_def.to_json}"}
       @output.puts(",") if [:wrote_node, :wrote_graph].include?(@state)
       if @current_node_def
         node_def = if context