json-ld 3.0.2 → 3.1.0

data/lib/json/ld/from_rdf.rb

@@ -23,7 +23,10 @@ module JSON::LD
       referenced_once = {}
 
       value = nil
-      ec = Context.new
+      ec = @context
+
+      # Create an entry for compound-literal node detection
+      compound_literal_subjects = {}
 
       # Create a map for node to object representation
 
@@ -32,14 +35,21 @@ module JSON::LD
         #log_debug("statement") { statement.to_nquads.chomp}
 
         name = statement.graph_name ? ec.expand_iri(statement.graph_name).to_s : '@default'
-        
+
         # Create a graph entry as needed
         node_map = graph_map[name] ||= {}
+        compound_literal_subjects[name] ||= {}
+
         default_graph[name] ||= {'@id' => name} unless name == '@default'
-        
+
         subject = ec.expand_iri(statement.subject).to_s
         node = node_map[subject] ||= {'@id' => subject}
 
+        # If predicate is rdf:datatype, note subject in compound literal subjects map
+        if @options[:rdfDirection] == 'compound-literal' && statement.predicate == RDF.to_uri + 'direction'
+          compound_literal_subjects[name][subject] ||= true
+        end
+
         # If object is an IRI or blank node identifier, and node map does not have an object member, create one and initialize its value to a new JSON object consisting of a single member @id whose value is set to object.
         node_map[statement.object.to_s] ||= {'@id' => statement.object.to_s} unless
           statement.object.literal?
@@ -50,8 +60,12 @@ module JSON::LD
           next
         end
 
-        # Set value to the result of using the RDF to Object Conversion algorithm, passing object and use native types.
-        value = ec.expand_value(nil, statement.object, useNativeTypes: useNativeTypes, log_depth: @options[:log_depth])
+        # Set value to the result of using the RDF to Object Conversion algorithm, passing object, rdfDirection, and use native types.
+        value = ec.expand_value(nil,
+                                statement.object,
+                                rdfDirection: @options[:rdfDirection],
+                                useNativeTypes: useNativeTypes,
+                                log_depth: @options[:log_depth])
 
         merge_value(node, statement.predicate.to_s, value)
 
@@ -77,6 +91,31 @@ module JSON::LD
 
       # For each name and graph object in graph map:
       graph_map.each do |name, graph_object|
+
+        # If rdfDirection is compound-literal, check referenced_once for entries from compound_literal_subjects
+        compound_literal_subjects.fetch(name, {}).keys.each do |cl|
+          node = referenced_once[cl][:node]
+          next unless node.is_a?(Hash)
+          property = referenced_once[cl][:property]
+          value = referenced_once[cl][:value]
+          cl_node = graph_map[name].delete(cl)
+          next unless cl_node.is_a?(Hash)
+          node[property].select do |v|
+            next unless v['@id'] == cl
+            v.delete('@id')
+            v['@value'] = cl_node[RDF.value.to_s].first['@value']
+            if cl_node[RDF.to_uri.to_s + 'language']
+              lang = cl_node[RDF.to_uri.to_s + 'language'].first['@value']
+              if lang !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
+                warn "i18n datatype language must be valid BCP47: #{lang.inspect}"
+              end
+              v['@language'] = lang
+            end
+            v['@direction'] = cl_node[RDF.to_uri.to_s + 'direction'].first['@value']
+          end
+        end
+
+        # Skip to next graph, unless this one has lists
         next unless nil_var = graph_object[RDF.nil.to_s]
 
         # For each item usage in the usages member of nil, perform the following steps:
@@ -101,18 +140,6 @@ module JSON::LD
             node, property, head = node_usage[:node], node_usage[:property], node_usage[:value]
           end
 
-          # If property equals rdf:first, i.e., the detected list is nested inside another list
-          #if property == RDF.first.to_s
-          #  # and the value of the @id of node equals rdf:nil, i.e., the detected list is empty, continue with the next usage item. The rdf:nil node cannot be converted to a list object as it would result in a list of lists, which isn't supported.
-          #  next if node['@id'] == RDF.nil.to_s
-          #
-          #  # Otherwise, the list consists of at least one item. We preserve the head node and transform the rest of the linked list to a list object
-          #  head_id = head['@id']
-          #  head = graph_object[head_id]
-          #  head = Array(head[RDF.rest.to_s]).first
-          #  list.pop; list_nodes.pop
-          #end
-
           head.delete('@id')
           head['@list'] = list.reverse
           list_nodes.each {|node_id| graph_object.delete(node_id)}

data/lib/json/ld/html/nokogiri.rb

@@ -0,0 +1,151 @@
+module JSON::LD
+  class API
+    ##
+    # Nokogiri implementation of an HTML parser.
+    #
+    # @see http://nokogiri.org/
+    module Nokogiri
+      ##
+      # Returns the name of the underlying XML library.
+      #
+      # @return [Symbol]
+      def self.library
+        :nokogiri
+      end
+
+      # Proxy class to implement uniform element accessors
+      class NodeProxy
+        attr_reader :node
+        attr_reader :parent
+
+        def initialize(node, parent = nil)
+          @node = node
+          @parent = parent
+        end
+
+        ##
+        # Return xml:base on element, if defined
+        #
+        # @return [String]
+        def base
+          @node.attribute_with_ns("base", RDF::XML.to_s) || @node.attribute('xml:base')
+        end
+
+        def display_path
+          @display_path ||= begin
+            path = []
+            path << parent.display_path if parent
+            path << @node.name
+            case @node
+            when ::Nokogiri::XML::Element then path.join("/")
+            when ::Nokogiri::XML::Attr    then path.join("@")
+            else path.join("?")
+            end
+          end
+        end
+
+        ##
+        # Return true of all child elements are text
+        #
+        # @return [Array<:text, :element, :attribute>]
+        def text_content?
+          @node.children.all? {|c| c.text?}
+        end
+
+        ##
+        # Children of this node
+        #
+        # @return [NodeSetProxy]
+        def children
+          NodeSetProxy.new(@node.children, self)
+        end
+
+        # Ancestors of this element, in order
+        def ancestors
+          @ancestors ||= parent ? parent.ancestors + [parent] : []
+        end
+
+        ##
+        # Inner text of an element. Decode Entities
+        #
+        # @return [String]
+        #def inner_text
+        #  coder = HTMLEntities.new
+        #  coder.decode(@node.inner_text)
+        #end
+
+        def attribute_nodes
+          @attribute_nodes ||= NodeSetProxy.new(@node.attribute_nodes, self)
+        end
+
+        def xpath(*args)
+          @node.xpath(*args).map do |n|
+            # Get node ancestors
+            parent = n.ancestors.reverse.inject(nil) do |p,node|
+              NodeProxy.new(node, p)
+            end
+            NodeProxy.new(n, parent)
+          end
+        end
+
+        ##
+        # Proxy for everything else to @node
+        def method_missing(method, *args)
+          @node.send(method, *args)
+        end
+      end
+
+      ##
+      # NodeSet proxy
+      class NodeSetProxy
+        attr_reader :node_set
+        attr_reader :parent
+
+        def initialize(node_set, parent)
+          @node_set = node_set
+          @parent = parent
+        end
+
+        ##
+        # Return a proxy for each child
+        #
+        # @yield child
+        # @yieldparam [NodeProxy]
+        def each
+          @node_set.each do |c|
+            yield NodeProxy.new(c, parent)
+          end
+        end
+
+        ##
+        # Proxy for everything else to @node_set
+        def method_missing(method, *args)
+          @node_set.send(method, *args)
+        end
+      end
+
+      ##
+      # Initializes the underlying XML library.
+      #
+      # @param  [Hash{Symbol => Object}] options
+      # @return [NodeProxy] of root element
+      def initialize_html(input, options = {})
+        require 'nokogiri' unless defined?(::Nokogiri)
+        doc = case input
+        when ::Nokogiri::HTML::Document, ::Nokogiri::XML::Document
+          input
+        else
+          begin
+            require 'nokogumbo' unless defined?(::Nokogumbo)
+            input = input.read if input.respond_to?(:read)
+            ::Nokogiri::HTML5(input.dup.force_encoding('utf-8'), max_parse_errors: 1000)
+          rescue LoadError
+            ::Nokogiri::HTML.parse(input, 'utf-8')
+          end
+        end
+
+        NodeProxy.new(doc.root) if doc && doc.root
+      end
+    end
+  end
+end

data/lib/json/ld/html/rexml.rb

@@ -0,0 +1,186 @@
+require 'htmlentities'
+
+module JSON::LD
+  class API
+    ##
+    # REXML implementation of an XML parser.
+    #
+    # @see http://www.germane-software.com/software/rexml/
+    module REXML
+      ##
+      # Returns the name of the underlying XML library.
+      #
+      # @return [Symbol]
+      def self.library
+        :rexml
+      end
+
+      # Proxy class to implement uniform element accessors
+      class NodeProxy
+        attr_reader :node
+        attr_reader :parent
+
+        def initialize(node, parent = nil)
+          @node = node
+          @parent = parent
+        end
+
+        ##
+        # Return xml:base on element, if defined
+        #
+        # @return [String]
+        def base
+          @node.attribute("base", RDF::XML.to_s) || @node.attribute('xml:base')
+        end
+
+        def display_path
+          @display_path ||= begin
+            path = []
+            path << parent.display_path if parent
+            path << @node.name
+            case @node
+            when ::REXML::Element   then path.join("/")
+            when ::REXML::Attribute then path.join("@")
+            else path.join("?")
+            end
+          end
+        end
+
+        ##
+        # Return true of all child elements are text
+        #
+        # @return [Array<:text, :element, :attribute>]
+        def text_content?
+          @node.children.all? {|c| c.is_a?(::REXML::Text)}
+        end
+
+        ##
+        # Children of this node
+        #
+        # @return [NodeSetProxy]
+        def children
+          NodeSetProxy.new(@node.children, self)
+        end
+
+        # Ancestors of this element, in order
+        def ancestors
+          @ancestors ||= parent ? parent.ancestors + [parent] : []
+        end
+
+        ##
+        # Inner text of an element
+        #
+        # @see http://apidock.com/ruby/REXML/Element/get_text#743-Get-all-inner-texts
+        # @return [String]
+        def inner_text
+          coder = HTMLEntities.new
+          ::REXML::XPath.match(@node,'.//text()').map { |e|
+            coder.decode(e)
+          }.join
+        end
+
+        ##
+        # Inner text of an element
+        #
+        # @see http://apidock.com/ruby/REXML/Element/get_text#743-Get-all-inner-texts
+        # @return [String]
+        def inner_html
+          @node.children.map(&:to_s).join
+        end
+
+        def attribute_nodes
+          attrs = @node.attributes.dup.keep_if do |name, attr|
+            !name.start_with?('xmlns')
+          end
+          @attribute_nodes ||= (attrs.empty? ? attrs : NodeSetProxy.new(attrs, self))
+        end
+
+        ##
+        # Node type accessors
+        #
+        # @return [Boolean]
+        def text?
+          @node.is_a?(::REXML::Text)
+        end
+
+        def element?
+          @node.is_a?(::REXML::Element)
+        end
+
+        def blank?
+          @node.is_a?(::REXML::Text) && @node.empty?
+        end
+
+        def to_s; @node.to_s; end
+
+        def xpath(*args)
+          ::REXML::XPath.match(@node, *args).map do |n|
+            NodeProxy.new(n, parent)
+          end
+        end
+
+        def at_xpath(*args)
+          xpath(*args).first
+        end
+
+        ##
+        # Proxy for everything else to @node
+        def method_missing(method, *args)
+          @node.send(method, *args)
+        end
+      end
+
+      ##
+      # NodeSet proxy
+      class NodeSetProxy
+        attr_reader :node_set
+        attr_reader :parent
+
+        def initialize(node_set, parent)
+          @node_set = node_set
+          @parent = parent
+        end
+
+        ##
+        # Return a proxy for each child
+        #
+        # @yield child
+        # @yieldparam [NodeProxy]
+        def each
+          @node_set.each do |c|
+            yield NodeProxy.new(c, parent)
+          end
+        end
+
+        ##
+        def to_html
+          node_set.map(&:to_s).join("")
+        end
+
+        ##
+        # Proxy for everything else to @node_set
+        def method_missing(method, *args)
+          @node_set.send(method, *args)
+        end
+      end
+
+      ##
+      # Initializes the underlying XML library.
+      #
+      # @param  [Hash{Symbol => Object}] options
+      # @return [NodeProxy] of document root
+      def initialize_html(input, options = {})
+        require 'rexml/document' unless defined?(::REXML)
+        doc = case input
+        when ::REXML::Document
+          input
+        else
+          # Only parse as XML, no HTML mode
+          ::REXML::Document.new(input.respond_to?(:read) ? input.read : input.to_s)
+        end
+
+        NodeProxy.new(doc.root) if doc && doc.root
+      end
+    end
+  end
+end

data/lib/json/ld/reader.rb

@@ -4,7 +4,7 @@ module JSON::LD
   ##
   # A JSON-LD parser in Ruby.
   #
-  # @see http://json-ld.org/spec/ED/20110507/
+  # @see https://www.w3.org/TR/json-ld11-api
   # @author [Gregg Kellogg](http://greggkellogg.net/)
   class Reader < RDF::Reader
     format Format
@@ -20,12 +20,32 @@ module JSON::LD
           datatype: RDF::URI,
           on: ["--expand-context CONTEXT"],
           description: "Context to use when expanding.") {|arg| RDF::URI(arg)},
+        RDF::CLI::Option.new(
+          symbol: :extractAllScripts,
+          datatype: TrueClass,
+          default: false,
+          control: :checkbox,
+          on: ["--[no-]extract-all-scripts"],
+          description: "If set to true, when extracting JSON-LD script elements from HTML, unless a specific fragment identifier is targeted, extracts all encountered JSON-LD script elements using an array form, if necessary.") {|arg| RDF::URI(arg)},
+        RDF::CLI::Option.new(
+          symbol: :lowercaseLanguage,
+          datatype: TrueClass,
+          control: :checkbox,
+          on: ["--[no-]lowercase-language"],
+          description: "By default, language tags are left as is. To normalize to lowercase, set this option to `true`."),
         RDF::CLI::Option.new(
           symbol: :processingMode,
           datatype: %w(json-ld-1.0 json-ld-1.1),
           control: :radio,
           on: ["--processingMode MODE", %w(json-ld-1.0 json-ld-1.1)],
           description: "Set Processing Mode (json-ld-1.0 or json-ld-1.1)"),
+        RDF::CLI::Option.new(
+          symbol: :rdfDirection,
+          datatype: %w(i18n-datatype compound-literal),
+          default: 'null',
+          control: :select,
+          on: ["--rdf-direction DIR", %w(i18n-datatype compound-literal)],
+          description: "How to serialize literal direction (i18n-datatype compound-literal)") {|arg| RDF::URI(arg)},
       ]
     end
 
@@ -39,7 +59,7 @@ module JSON::LD
     # @yieldparam  [RDF::Reader] reader
     # @yieldreturn [void] ignored
     # @raise [RDF::ReaderError] if the JSON document cannot be loaded
-    def initialize(input = $stdin, options = {}, &block)
+    def initialize(input = $stdin, **options, &block)
       options[:base_uri] ||= options[:base]
       super do
         @options[:base] ||= base_uri.to_s if base_uri
@@ -65,7 +85,7 @@ module JSON::LD
     # @private
     # @see   RDF::Reader#each_statement
     def each_statement(&block)
-      JSON::LD::API.toRdf(@doc, @options, &block)
+      JSON::LD::API.toRdf(@doc, **@options, &block)
     rescue ::JSON::ParserError, ::JSON::LD::JsonLdError => e
       log_fatal("Failed to parse input document: #{e.message}", exception: RDF::ReaderError)
     end
@@ -75,8 +95,8 @@ module JSON::LD
     # @see   RDF::Reader#each_triple
     def each_triple(&block)
       if block_given?
-        JSON::LD::API.toRdf(@doc, @options) do |statement|
-          yield *statement.to_triple
+        JSON::LD::API.toRdf(@doc, **@options) do |statement|
+          yield(*statement.to_triple)
         end
       end
       enum_for(:each_triple)