yaml-ld 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c57dc93098e9dbf2ab68a8ffd6342fe1b838015e1335496ed918293d1fee4381
-  data.tar.gz: d1f7c955b184e680448354bab9f3b4ced1c0f11150f7c9cec67ec6feed4148fd
+  metadata.gz: c1da1570067d55e5cf71f757cfb5a2e2d8313dc9f63fe045bafde65dcb220a02
+  data.tar.gz: '0096c9115d43889554b3e7f6d7ac92d7c8b94b4adce85d8b811f0321186d9dd0'
 SHA512:
-  metadata.gz: 4917c179d4ef8c0d1f472e9e2be96fbfb82a76d3b554f2a90fdc610864a4ff0355e3a80806d2bf02de75831f84d17bebc056673d41f4ccf3e7cd2d80726864cd
-  data.tar.gz: f8d302927836ecfaf4c8e7d6afb209071e772fbd6e75a5622683fd35fbf2f54a123d8e73752934e9d441c791cb6e712e05c0b0b39f0cb5105e9383008f2712be
+  metadata.gz: ea19a5310f145f5abb060fd54903f42312a60d197a268ec3a66ba4421ed0497e3f93b1b8b930cda9797bc00aa92d18d9ca1fb7a633cdf9bf7f37bcac1cc50426
+  data.tar.gz: a861b85988b30f42bb3afdf7d2ecae69663ca069081b4921303c07c72bc17bc19d4fea27c21ce8a2d027b256a5079581deeb5c9dc0a864fe95edd5420b9a8b8b

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/psych/amazing_print.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Amazing Print extensions for Psych
+#------------------------------------------------------------------------------
+module AmazingPrint
+  module Psych
+    def self.included(base)
+      base.send :alias_method, :cast_without_psych, :cast
+      base.send :alias_method, :cast, :cast_with_psych
+    end
+
+    # Add Psych Node names to the dispatcher pipeline.
+    #------------------------------------------------------------------------------
+    def cast_with_psych(object, type)
+      cast = cast_without_psych(object, type)
+      if (defined?(::Psych::Nodes::Node) && object.is_a?(::Psych::Nodes::Node))
+        cast = :psych_node
+      end
+      cast
+    end
+
+STYLES = %w(ANY BLOCK FLOW)    #------------------------------------------------------------------------------
+    def awesome_psych_node(object)
+      contents = []
+      contents << colorize(object.class.name.split('::').last, :class)
+      contents << colorize("!<#{object.tag}>", :args) if object.tag
+      contents << colorize("&#{object.anchor}", :args) if object.respond_to?(:anchor) && object.anchor
+      contents << colorize("(implicit)", :args) if object.respond_to?(:implicit) && object.implicit
+      contents << colorize("(implicit end)", :args) if object.respond_to?(:implicit_end) && object.implicit_end
+      case object
+      when ::Psych::Nodes::Stream
+        contents << awesome_array(object.children)
+      when ::Psych::Nodes::Document
+        contents << colorize('%TAG(' + object.tag_directives.flatten.join(' ') + ')', :args) unless Array(object.tag_directives).empty?
+        contents << colorize("version #{object.version.join('.')}", :args) if object.version
+        contents << awesome_array(object.children)
+      when ::Psych::Nodes::Sequence
+        style = %w(ANY BLOCK FLOW)[object.style.to_i]
+        contents << awesome_array(object.children)
+      when ::Psych::Nodes::Mapping
+        style = %w(ANY BLOCK FLOW)[object.style.to_i]
+        contents << colorize(style, :args) if object.style
+        contents << awesome_hash(object.children.each_slice(2).to_h)
+      when ::Psych::Nodes::Scalar
+        style = %w(ANY PLAIN SINGLE_QUOTED DOUBLE_QUOTED LITERAL FOLDED)[object.style.to_i]
+        contents << colorize(style, :args) if object.style
+        contents << colorize("(plain)", :args) if object.plain
+        contents << colorize("(quoted)", :args) if object.quoted
+        contents << awesome_simple(object.value.inspect, :variable)
+      when ::Psych::Nodes::Alias
+        # No children
+      else
+        "Unknown node type: #{object.inspect}"
+      end
+
+      contents.join(' ')
+    end
+  end
+end
+
+AmazingPrint::Formatter.include AmazingPrint::Psych

data/lib/yaml_ld/api.rb

@@ -9,7 +9,6 @@ module YAML_LD
   # @see https://www.w3.org/TR/json-ld11-api/#the-application-programming-interface
   # @author [Gregg Kellogg](http://greggkellogg.net/)
   class API < ::JSON::LD::API
-
     # The following constants are used to reduce object allocations
     LINK_REL_CONTEXT = %w(rel http://www.w3.org/ns/yaml-ld#context).freeze
     LINK_REL_ALTERNATE = %w(rel alternate).freeze
@@ -30,6 +29,35 @@ module YAML_LD
     #   A Serializer method used for generating the YAML serialization of the result. If absent, the internal Ruby objects are returned, which can be transformed to YAML externally via `#to_yaml`.
     #   See {YAML_LD::API.serializer}.
     # @param  [Hash{Symbol => Object}] options
+    # @option options [RDF::URI, String, #to_s] :base
+    #   The Base IRI to use when expanding the document. This overrides the value of `input` if it is a _IRI_. If not specified and `input` is not an _IRI_, the base IRI defaults to the current document IRI if in a browser context, or the empty string if there is no document context. If not specified, and a base IRI is found from `input`, options[:base] will be modified with this value.
+    # @option options [Boolean] :compactArrays (true)
+    #   If set to `true`, the JSON-LD processor replaces arrays with just one element with that element during compaction. If set to `false`, all arrays will remain arrays even if they have just one element.
+    # @option options [Boolean] :compactToRelative (true)
+    #   Creates document relative IRIs when compacting, if `true`, otherwise leaves expanded.
+    # @option options [Proc] :documentLoader
+    #   The callback of the loader to be used to retrieve remote documents and contexts. If specified, it must be used to retrieve remote documents and contexts; otherwise, if not specified, the processor's built-in loader must be used. See {documentLoader} for the method signature.
+    # @option options [String, #read, Hash, Array, JSON::LD::Context] :expandContext
+    #   A context that is used to initialize the active context when expanding a document.
+    # @option options [Boolean] :extendedYAML (false)
+    #   Use the expanded internal representation.
+    # @option options [Boolean] :extractAllScripts
+    #   If set, when given an HTML input without a fragment identifier, extracts all `script` elements with type `application/ld+json` into an array during expansion.
+    # @option options [Boolean, String, RDF::URI] :flatten
+    #   If set to a value that is not `false`, the JSON-LD processor must modify the output of the Compaction Algorithm or the Expansion Algorithm by coalescing all properties associated with each subject via the Flattening Algorithm. The value of `flatten must` be either an _IRI_ value representing the name of the graph to flatten, or `true`. If the value is `true`, then the first graph encountered in the input document is selected and flattened.
+    # @option options [String] :language
+    #   When set, this has the effect of inserting a context definition with `@language` set to the associated value, creating a default language for interpreting string values.
+    # @option options [Boolean] :lowercaseLanguage
+    #   By default, language tags are left as is. To normalize to lowercase, set this option to `true`.
+    # @option options [Boolean] :ordered (true)
+    #   Order traversal of dictionary members by key when performing algorithms.
+    # @option options [Boolean] :rdfstar      (false)
+    #   support parsing JSON-LD-star statement resources.
+    # @option options [Boolean] :rename_bnodes (true)
+    #   Rename bnodes as part of expansion, or keep them the same.
+    # @option options [Boolean]  :unique_bnodes   (false)
+    #   Use unique bnode identifiers, defaults to using the identifier which the node was originally initialized with (if any).
+    # @option options [Boolean] :validate Validate input, if a string or readable object.
     # @raise [JsonLdError]
     # @yield YAML_LD, base_iri
     # @yieldparam [Array<Hash>] yamlld
@@ -46,7 +74,10 @@ module YAML_LD
                     **options,
                     &block)
       JSON::LD::API.expand(input,
+                           allowed_content_types: %r(application/(.+\+)?yaml),
                            documentLoader: documentLoader, 
+                           extendedRepresentation: options[:extendedYAML],
+                           processingMode: 'json-ld-1.1',
                            serializer: serializer,
                            **options,
                            &block)
@@ -68,7 +99,7 @@ module YAML_LD
     #   See {YAML_LD::API.serializer}.
     # @param [Boolean] expanded (false) Input is already expanded
     # @param  [Hash{Symbol => Object}] options
-    # @option options (see #initialize)
+    # @option options (see expand)
     # @yield YAML_LD
     # @yieldparam [Array<Hash>] yamlld
     #   The expanded YAML-LD document
@@ -83,7 +114,10 @@ module YAML_LD
                      **options,
                      &block)
       JSON::LD::API.compact(input, context, expanded: expanded,
+                           allowed_content_types: %r(application/(.+\+)?yaml),
                            documentLoader: documentLoader, 
+                           extendedRepresentation: options[:extendedYAML],
+                           processingMode: 'json-ld-1.1',
                            serializer: serializer,
                            **options,
                            &block)
@@ -103,9 +137,11 @@ module YAML_LD
     #   A Serializer method used for generating the YAML serialization of the result. If absent, the internal Ruby objects are returned, which can be transformed to YAML externally via `#to_yaml`.
     #   See {YAML_LD::API.serializer}.
     # @param  [Hash{Symbol => Object}] options
-    # @option options (see #initialize)
+    # @option options (see expand)
     # @option options [Boolean] :createAnnotations
     #   Unfold embedded nodes which can be represented using `@annotation`.
+    # @option options [Boolean] :extendedYAML (false)
+    #   Use the expanded internal representation.
     # @yield YAML_LD
     # @yieldparam [Array<Hash>] yamlld
     #   The expanded YAML-LD document
@@ -119,7 +155,10 @@ module YAML_LD
                      **options,
                      &block)
       JSON::LD::API.flatten(input, context, expanded: expanded,
+                            allowed_content_types: %r(application/(.+\+)?yaml),
                             documentLoader: documentLoader, 
+                            extendedRepresentation: options[:extendedYAML],
+                            processingMode: 'json-ld-1.1',
                             serializer: serializer,
                             **options,
                             &block)
@@ -135,11 +174,13 @@ module YAML_LD
     # @param [String, #read, Hash, Array] frame
     #   The frame to use when re-arranging the data.
     # @param [Boolean] expanded (false) Input is already expanded
-    # @option options (see #initialize)
+    # @option options (see expand)
     # @option options ['@always', '@link', '@once', '@never'] :embed ('@once')
     #   a flag specifying that objects should be directly embedded in the output, instead of being referred to by their IRI.
     # @option options [Boolean] :explicit (false)
     #   a flag specifying that for properties to be included in the output, they must be explicitly declared in the framing context.
+    # @option options [Boolean] :extendedYAML (false)
+    #   Use the expanded internal representation.
     # @option options [Boolean] :requireAll (false)
     #   A flag specifying that all properties present in the input frame must either have a default value or be present in the JSON-LD input for the frame to match.
     # @option options [Boolean] :omitDefault (false)
@@ -160,7 +201,10 @@ module YAML_LD
                    **options,
                    &block)
       JSON::LD::API.frame(input, frame, expanded: expanded,
+                          allowed_content_types: %r(application/(.+\+)?yaml),
                           documentLoader: documentLoader, 
+                          extendedRepresentation: options[:extendedYAML],
+                          processingMode: 'json-ld-1.1',
                           serializer: serializer,
                           **options,
                           &block)
@@ -172,7 +216,9 @@ module YAML_LD
     # @param [String, #read, Hash, Array] input
     #   The YAML-LD object to process when outputting statements.
     # @param [Boolean] expanded (false) Input is already expanded
-    # @option options (see #initialize)
+    # @option options (see expand)
+    # @option options [Boolean] :extendedYAML (false)
+    #   Use the expanded internal representation.
     # @option options [Boolean] :produceGeneralizedRdf (false)
     #   If true, output will include statements having blank node predicates, otherwise they are dropped.
     # @raise [JsonLdError]
@@ -184,7 +230,10 @@ module YAML_LD
                    **options,
                    &block)
       JSON::LD::API.toRdf(input, expanded: expanded,
+                          allowed_content_types: %r(application/(.+\+)?yaml),
                           documentLoader: documentLoader, 
+                          extendedRepresentation: options[:extendedYAML],
+                          processingMode: 'json-ld-1.1',
                           **options,
                           &block)
     end
@@ -202,7 +251,9 @@ module YAML_LD
     #   A Serializer method used for generating the YAML serialization of the result. If absent, the internal Ruby objects are returned, which can be transformed to YAML externally via `#to_yaml`.
     #   See {YAML_LD::API.serializer}.
     # @param  [Hash{Symbol => Object}] options
-    # @option options (see #initialize)
+    # @option options (see expand)
+    # @option options [Boolean] :extendedYAML (false)
+    #   Use the expanded internal representation.
     # @yield jsonld
     # @yieldparam [Hash] jsonld
     #   The JSON-LD document in expanded form
@@ -215,10 +266,13 @@ module YAML_LD
                      **options,
                      &block)
       JSON::LD::API.fromRdf(input,
-                            useRdfType: useRdfType,
-                            useNativeTypes: useNativeTypes,
+                            allowed_content_types: %r(application/(.+\+)?yaml),
                             documentLoader: documentLoader, 
+                            extendedRepresentation: options[:extendedYAML],
+                            processingMode: 'json-ld-1.1',
                             serializer: serializer,
+                            useRdfType: useRdfType,
+                            useNativeTypes: useNativeTypes,
                             **options,
                             &block)
     end
@@ -257,7 +311,7 @@ module YAML_LD
         content = case content_type
         when nil, %r(application/(\w+\+)*yaml)
           # Parse YAML
-          Psych.safe_load(url.read, aliases: true)
+          Representation.load(url.read, filename: url.to_s, **options)
         else
           url.read
         end
@@ -267,7 +321,11 @@ module YAML_LD
           contextUrl: context_url))
       elsif url.to_s.match?(/\.yaml\w*$/) || content_type.to_s.match?(%r(application/(\w+\+)*yaml))
         # Parse YAML
-        block.call(RemoteDocument.new(Psych.load_file(url.to_s, aliases: true),
+        content = Representation.load(RDF::Util::File.open_file(url.to_s).read,
+                                             filename: url.to_s,
+                                             **options)
+
+        block.call(RemoteDocument.new(content,
           documentUrl: base_uri,
           contentType: content_type,
           contextUrl: context_url))
@@ -288,7 +346,7 @@ module YAML_LD
     #   options passed from the invoking context.
     def self.serializer(object, *args, **options)
       # de-alias any objects to avoid the use of aliases and anchors
-      "%YAML 1.2\n" + Psych.dump(object, **options)
+      "%YAML 1.2\n" + Representation.dump(object, **options)
     end
   end
 end

data/lib/yaml_ld/format.rb

@@ -1,5 +1,7 @@
 # -*- encoding: utf-8 -*-
 # frozen_string_literal: true
+require 'json/ld/format'
+
 module YAML_LD
   ##
   # YAML-LD format specification.
@@ -28,6 +30,25 @@ module YAML_LD
     reader { YAML_LD::Reader }
     writer { YAML_LD::Writer }
 
+    # Specify how to execute CLI commands for each supported format. These are added to the `LD_FORMATS` defined for `JSON::LD::Format`
+    # Derived formats (e.g., YAML-LD) define their own entrypoints.
+    LD_FORMATS = {
+      yamlld: {
+        expand: ->(input, **options) {
+          YAML_LD::API.expand(input, validate: false, **options)
+        },
+        compact: ->(input, **options) {
+          YAML_LD::API.compact(input, options[:context], **options)
+        },
+        flatten: ->(input, **options) {
+          YAML_LD::API.flatten(input, options[:context], **options)
+        },
+        frame: ->(input, **options) {
+          YAML_LD::API.frame(input, options[:frame], **options)
+        },
+      }
+    }
+
     ##
     # Sample detection to see if it matches YAML-LD
     #
@@ -54,3 +75,7 @@ module YAML_LD
     end
   end
 end
+
+
+# Load into JSON::LD::Format::LD_FORMATS
+::JSON::LD::Format.const_get(:LD_FORMATS).merge!(::YAML_LD::Format::LD_FORMATS)

data/lib/yaml_ld/reader.rb

@@ -24,7 +24,9 @@ module YAML_LD
     def initialize(input = $stdin,
       documentLoader: YAML_LD::API.method(:documentLoader),
       **options, &block)
-      input = StringIO.new(input) if input.is_a?(String)
+      input = StringIO.new(input).tap do |d|
+        d.define_singleton_method(:content_type) {'application/ld+yaml'}
+      end if input.is_a?(String)
       super(input, documentLoader: documentLoader, **options, &block)
     end
 

data/lib/yaml_ld/representation.rb

@@ -0,0 +1,256 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+require 'psych'
+require 'rdf/xsd'
+
+module YAML_LD
+  ##
+  # Transforms a Psych AST to the JSON-LD (extended) Internal Representation build using `Psych.parse`, `.parse_stream`, or `parse_file`.
+  #
+  # FIXME: Aliases
+  module Representation
+    ###
+    # Load multiple documents given in +yaml+.  Returns the parsed documents
+    # as a list.  If a block is given, each document will be converted to Ruby
+    # and passed to the block during parsing
+    #
+    # @example
+    #
+    #   load_stream("--- foo\n...\n--- bar\n...") # => ['foo', 'bar']
+    #
+    #   list = []
+    #   load_stream("--- foo\n...\n--- bar\n...") do |ruby|
+    #     list << ruby
+    #   end
+    #   list # => ['foo', 'bar']
+    #
+    # @param [String] yaml
+    # @param [String] filename
+    # @param [Object] fallback
+    # @param [Hash{Symbol => Object}] options
+    # @return [Array<Object>]
+    def load_stream(yaml, filename: nil, fallback: [], **options)
+      result = if block_given?
+        Psych.parse_stream(yaml, filename: filename) do |node|
+          yield as_jsonld_ir(node, **options)
+        end
+      else
+        as_jsonld_ir(Psych.parse_stream(yaml, filename: filename), **options)
+      end
+
+      result.is_a?(Array) && result.empty? ? fallback : result
+    end
+    module_function :load_stream
+
+    ##
+    # Load a single document from +yaml+.
+    # @param (see load_stream)
+    # @return [Object]
+    def load(yaml, filename: nil, fallback: nil, **options)
+      result = if block_given?
+        load_stream(yaml, filename: filename, **options) do |node|
+          yield node.first
+        end
+      else
+        load_stream(yaml, filename: filename, **options).first
+      end
+
+      result || fallback
+    end
+    module_function :load
+
+    ##
+    # Dump internal representaiton to YAML
+    #
+    # @option options[Boolean] :extendedYAML
+    #   Allows the use of aliases and encodes RDF::Literals
+    def dump(ir, **options)
+      if options[:extendedYAML]
+        options = {
+          aliases: true,
+          permitted_classes: [RDF::Literal]
+        }.merge(options)
+      else
+        # Deep duplicate representation to avoid alias nodes
+        ir = deep_dup(ir)
+      end
+      visitor = Representation::IRTree.create(options)
+      visitor << ir
+      visitor.tree.yaml
+    end
+    module_function :dump
+
+    def deep_dup(obj)
+      case obj
+      when Array then obj.map {|e| deep_dup(e)}
+      when Hash then obj.inject({}) {|memo, (k,v)| memo.merge(k => deep_dup(v))}
+      else obj # No need to de-dup
+      end
+    end
+    module_function :deep_dup
+
+    ##
+    # Transform a Psych::Nodes::Node to the JSON-LD Internal Representation
+    #
+    # @param [Psych::Nodes::Node] node
+    # @param [Hash{Symbol => Object}] options
+    # @option options [Boolean] :extendedYAML (false)
+    #   Use the expanded internal representation.
+    # @return [Object]
+    def as_jsonld_ir(node, **options)
+      # Scans scalars for built-in classes
+      @ss ||= Psych::ScalarScanner.new(Psych::ClassLoader::Restricted.new([], %i()))
+      case node
+      when Psych::Nodes::Stream
+        node.children.map {|n| as_jsonld_ir(n, **options)}
+      when Psych::Nodes::Document then as_jsonld_ir(node.children.first, **options)
+      when Psych::Nodes::Sequence then node.children.map {|n| as_jsonld_ir(n, **options)}
+      when Psych::Nodes::Mapping
+        node.children.each_slice(2).inject({}) do |memo, (k,v)|
+          memo.merge(as_jsonld_ir(k) => as_jsonld_ir(v, **options))
+        end
+      when ::Psych::Nodes::Scalar then scan_scalar(node, **options)
+      when ::Psych::Nodes::Alias
+        # FIXME
+      end
+    end
+    module_function :as_jsonld_ir
+
+    ##
+    # Scans a scalar value to a JSON-LD IR scalar value.
+    # Quoted scalar values are not interpreted.
+    #
+    # @param [Psych::Nodes::Scalar] node
+    # @param [Hash{Symbol => Object}] options
+    # @option options [Boolean] :extendedYAML (false)
+    #   Use the expanded internal representation.
+    # @return [Object]
+    def scan_scalar(node, **options)
+      return node.value if node.quoted # No interpretation
+      case node.tag
+      when "", NilClass
+        # Tokenize, but prohibit certain types
+        case node.value
+          # Don't scan some scalar values to types other than string
+        when Psych::ScalarScanner::TIME,
+             /^\d{4}-(?:1[012]|0\d|\d)-(?:[12]\d|3[01]|0\d|\d)$/, # Date
+             /^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}$/, # Time to seconds
+             /^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}\.[0-9_]*$/ # Time to seconds
+          node.value
+        else
+           @ss.tokenize(node.value)
+        end
+      when '!str', 'tag:yaml.org,2002:str'
+        node.value
+      when '!int', 'tag:yaml.org,2002:int'
+        Integer(node.value)
+      when "!float", "tag:yaml.org,2002:float"
+        Float(@ss.tokenize(node.value))
+      when "!null", "tag:yaml.org,2002:null"
+        nil
+      when "!bool", "tag:yaml.org,2002:bool"
+        node.value.downcase == 'true'
+      when %r(^https://www.w3.org/ns/i18n)
+        l_d = node.tag[26..-1]
+        l_d = l_d[1..-1] if l_d.start_with?('#')
+        l, d = l_d.split('_')
+        if !options[:extendedYAML]
+          (node.style== Psych::Nodes::Scalar::PLAIN ? @ss.tokenize(node.value) : node.value)
+        elsif d.nil?
+          # Just use language component
+          RDF::Literal(node.value, language: l)
+        else
+          # Language and direction
+          RDF::Literal(node.value, datatype: RDF::URI("https://www.w3.org/ns/i18n##{l_d}"))
+        end
+      else
+        tag = node.tag
+        options[:extendedYAML] ?
+          RDF::Literal(node.value, datatype: RDF::URI(tag), validate: true) :
+          (node.style== Psych::Nodes::Scalar::PLAIN ? @ss.tokenize(node.value) : node.value)
+      end
+    end
+    module_function :scan_scalar
+
+    ##
+    # Build a YAML AST with an RDF::Literal visitor
+    #
+    #
+    #   builder = Psych::Visitors::YAMLTree.new
+    #   builder << { :foo => 'bar' }
+    #   builder.tree # => #<Psych::Nodes::Stream .. }
+    #   builder.tree.yaml # => "..."
+    #
+    # @note Rails 6.0 not compatible with Psych 4.0, which defines `RestrictedYamlTree`.
+    class IRTree < (Psych::Visitors.const_defined?(:RestrictedYamlTree) ? Psych::Visitors::RestrictedYAMLTree : Psych::Visitors::YAMLTree)
+      ##
+      # Retrive the literals from an object
+      def datatypes(object)
+        case object
+        when Array        then object.inject([]) {|memo, o| memo += datatypes(o)}
+        when Hash         then object.values.inject([]) {|memo, o| memo += datatypes(o)}
+        when RDF::Literal then object.datatype? ? [object.datatype] : []
+        else []
+        end
+      end
+
+      ##
+      # Add the object to be emitted. If the `:extended` option is set when the visitor is created, tags are added to the document.
+      def push object
+        start unless started?
+        version = []
+        version = [1,1] if @options[:header]
+
+        case @options[:version]
+        when Array
+          version = @options[:version]
+        when String
+          version = @options[:version].split('.').map { |x| x.to_i }
+        else
+          version = [1,1]
+        end if @options.key? :version
+
+        dts = datatypes(object).uniq
+        tags = dts.inject({}) do |memo, dt|
+          # Find the most suitable voabulary, if any
+          if memo.keys.any? {|u| dt.to_s.start_with?(u)}
+            memo
+            # Already have a prefix for this
+          elsif vocab = RDF::Vocabulary.each.to_a.detect {|v| dt.to_s.index(v.to_uri.to_s) == 0}
+            # Index by vocabulary URI
+            memo.merge(vocab.to_uri.to_s => "!#{vocab.__prefix__}!")
+          else
+            memo
+          end
+        end
+        
+        @emitter.start_document version, tags.invert.to_a, false
+        accept object
+        @emitter.end_document !@emitter.streaming?
+      end
+      alias :<< :push
+
+      ##
+      # Emit an RDF Literal. If `extended` is set, use the datatype as an tag,
+      # otherwise, emit in expanded form.
+      def visit_RDF_Literal o
+        tag = case o.datatype
+        when nil then nil
+        when RDF::XSD.string then nil
+        when RDF.langString
+          "https://www.w3.org/ns/i18n##{o.language}" if @options[:extendedYAML]
+        else
+          if o.datatype.to_s.start_with?('https://www.w3.org/ns/i18n#')
+            o.datatype.to_s if @options[:extendedYAML]
+          elsif @options[:extendedYAML]
+            o.datatype.to_s
+          else
+            nil
+          end
+        end
+        formatted = o.value
+        register o, @emitter.scalar(formatted, nil, tag, false, false, Psych::Nodes::Scalar::PLAIN)
+      end
+    end
+  end
+end

data/lib/yaml_ld/version.rb

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 # frozen_string_literal: true
 module YAML_LD::VERSION
-  VERSION_FILE = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "..", "VERSION")
+  VERSION_FILE = File.expand_path("../../../VERSION", __FILE__)
   MAJOR, MINOR, TINY, EXTRA = File.read(VERSION_FILE).chomp.split(".")
 
   STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')

data/lib/yaml_ld.rb

@@ -28,6 +28,7 @@ module YAML_LD
 
   autoload :API,                'yaml_ld/api'
   autoload :Reader,             'yaml_ld/reader'
+  autoload :Representation,     'yaml_ld/representation'
   autoload :VERSION,            'yaml_ld/version'
   autoload :Writer,             'yaml_ld/writer'