class RDF::JSON::Reader

RDF/JSON parser.

@example Loading RDF/JSON parsing support

require 'rdf/json'

@example Obtaining an RDF/JSON reader class

RDF::Reader.for(:rj)         #=> RDF::JSON::Reader
RDF::Reader.for("etc/doap.rj")
RDF::Reader.for(:file_name      => "etc/doap.rj")
RDF::Reader.for(:file_extension => "rj")
RDF::Reader.for(:content_type   => "application/rj")

@example Parsing RDF statements from an RDF/JSON file

RDF::JSON::Reader.open("etc/doap.rj") do |reader|
  reader.each_statement do |statement|
    puts statement.inspect
  end
end

@example Parsing RDF statements from an RDF/JSON string

data = StringIO.new(File.read("etc/doap.rj"))
RDF::JSON::Reader.new(data) do |reader|
  reader.each_statement do |statement|
    puts statement.inspect
  end
end

@see n2.talis.com/wiki/RDF_JSON_Specification

Attributes

graph[R]

The graph constructed when parsing.

@return [RDF::Graph]

Public Class Methods

new(input = $stdin, **options, &block) click to toggle source

Initializes the RDF/JSON reader instance.

@param [IO, File, String] input @param [Hash{Symbol => Object}] options

any additional options (see `RDF::Reader#initialize`)

@yield [reader] ‘self` @yieldparam [RDF::Reader] reader @yieldreturn [void] ignored

Calls superclass method
# File lib/rdf/json/reader.rb, line 50
def initialize(input = $stdin, **options, &block)
  super do
    if block_given?
      case block.arity
        when 0 then instance_eval(&block)
        else block.call(self)
      end
    end
  end
end

Public Instance Methods

each_statement() { |Statement(subject, predicate, object)| ... } click to toggle source

@private @see RDF::Reader#each_statement

# File lib/rdf/json/reader.rb, line 143
def each_statement(&block)
  if block_given?
    @input.rewind rescue nil
    begin
      ::JSON.parse(@input.read).each do |subject, predicates|
        subject = parse_subject(subject)
        predicates.each do |predicate, objects|
          predicate = parse_predicate(predicate)
          objects.each do |object|
            object = parse_object(object)
            yield RDF::Statement(subject, predicate, object) if object
          end
        end
      end
    rescue ::JSON::ParserError => e
      log_error(e.message)
    end
    if validate? && log_statistics[:error]
      raise RDF::ReaderError, "Errors found during processing"
    end
  end
  enum_for(:each_statement)
end
each_triple(&block) click to toggle source

@private @see RDF::Reader#each_triple

# File lib/rdf/json/reader.rb, line 170
def each_triple(&block)
  if block_given?
    each_statement do |statement|
      block.call(*statement.to_triple)
    end
  end
  enum_for(:each_triple)
end
parse_bnode(string)
Alias for: parse_node
parse_node(string) click to toggle source

Parses an RDF/JSON blank node string into an ‘RDF::Node` instance.

@param [String] string @return [RDF::Node] @since 0.3.0

# File lib/rdf/json/reader.rb, line 118
def parse_node(string)
  @nodes ||= {}
  id = string[2..-1] # strips off the initial '_:'
  @nodes[id.to_sym] ||= RDF::Node.new(id)
end
Also aliased as: parse_bnode
parse_object(object) click to toggle source

Parses an RDF/JSON object string into an RDF value.

@param [Hash{String => Object}] object @return [RDF::Value]

# File lib/rdf/json/reader.rb, line 88
def parse_object(object)
  log_error("missing 'type' key in #{object.inspect}", exception: RDF::ReaderError) unless object.has_key?('type')
  log_error("missing 'value' key in #{object.inspect}", exception: RDF::ReaderError) unless object.has_key?('value')

  case type = object['type']
    when 'bnode'
      parse_node(object['value'])
    when 'uri'
      parse_uri(object['value'])
    when 'literal'
      literal = RDF::Literal.new(object['value'],
        language: object['lang'],
        datatype: object['datatype'],
        )
      literal.validate!     if validate?
      literal.canonicalize! if canonicalize?
      literal
    else
      log_error("expected 'type' to be 'bnode', 'uri', or 'literal', but got #{type.inspect}", exception: RDF::ReaderError)
  end
rescue RDF::ReaderError
  nil
end
parse_predicate(predicate) click to toggle source

Parses an RDF/JSON predicate string into a URI reference.

@param [String] predicate @return [RDF::URI]

# File lib/rdf/json/reader.rb, line 78
def parse_predicate(predicate)
  # TODO: optional support for CURIE predicates? (issue #1 on GitHub).
  parse_uri(predicate, :intern => true)
end
parse_subject(subject) click to toggle source

Parses an RDF/JSON subject string into a URI reference or blank node.

@param [String] subject @return [RDF::Resource]

# File lib/rdf/json/reader.rb, line 66
def parse_subject(subject)
  case subject
    when /^_:/ then parse_node(subject)
    else parse_uri(subject)
  end
end
parse_uri(string, **options) click to toggle source

Parses an RDF/JSON URI string into an ‘RDF::URI` instance.

@param [String] string @param [Hash{Symbol => Object}] options @option options [Boolean] :intern (false) @return [RDF::URI] @since 0.3.0

# File lib/rdf/json/reader.rb, line 133
def parse_uri(string, **options)
  uri = RDF::URI.send(intern = intern? && options[:intern] ? :intern : :new, string)
  uri.validate!     if validate?
  uri.canonicalize! if canonicalize? && !intern
  uri
end