yaml-ld 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c57dc93098e9dbf2ab68a8ffd6342fe1b838015e1335496ed918293d1fee4381
+  data.tar.gz: d1f7c955b184e680448354bab9f3b4ced1c0f11150f7c9cec67ec6feed4148fd
+SHA512:
+  metadata.gz: 4917c179d4ef8c0d1f472e9e2be96fbfb82a76d3b554f2a90fdc610864a4ff0355e3a80806d2bf02de75831f84d17bebc056673d41f4ccf3e7cd2d80726864cd
+  data.tar.gz: f8d302927836ecfaf4c8e7d6afb209071e772fbd6e75a5622683fd35fbf2f54a123d8e73752934e9d441c791cb6e712e05c0b0b39f0cb5105e9383008f2712be

data/AUTHORS

@@ -0,0 +1 @@
+* Gregg Kellogg <gregg@greggkellogg.net>

data/README.md

@@ -0,0 +1,150 @@
+# YAML-LD reader/writer
+
+Ruby [YAML-LD][] reader/writer for RDF.rb
+
+[![Gem Version](https://badge.fury.io/rb/yaml-ld.png)](https://rubygems.org/gems/yaml-ld)
+[![Build Status](https://secure.travis-ci.org/ruby-rdf/yaml-ld.png?branch=develop)](https://github.com/ruby-rdf/yaml-ld/actions?query=workflow%3ACI)
+[![Coverage Status](https://coveralls.io/repos/ruby-rdf/yaml-ld/badge.svg?branch=develop)](https://coveralls.io/github/ruby-rdf/yaml-ld?branch=develop)
+[![Gitter chat](https://badges.gitter.im/ruby-rdf.png)](https://gitter.im/gitterHQ/gitter)
+
+## Features
+
+YAML_LD parses and serializes [YAML-LD][] into [RDF][].
+
+As the specification is under development, this gem should be considered **experimental** and is subject to change at any time.
+
+YAML-LD documents may use frames or contexts described either using [JSON-LD][] or [YAML-LD][].
+
+* Process YAML-LD source using JSON-LD Context or Frame.
+* Process JSON-LD source using YAML-LD Context or Frame.
+
+## Examples
+
+    require 'rubygems'
+    require 'yaml\_ld'
+
+### Expand a YAML-LD Document
+
+    input = StringIO.new(%(
+    "@context":
+      "@vocab": http://xmlns.com/foaf/0.1/
+    name: Gregg Kellogg
+    homepage: https://greggkellogg.net
+    depiction: http://www.gravatar.com/avatar/42f948adff3afaa52249d963117af7c8
+    ))
+
+    YAML_LD::API.expand(input) # => %(
+    %YAML 1.2
+    ---
+    - http://xmlns.com/foaf/0.1/name:
+      - "@value": Gregg Kellogg
+      http://xmlns.com/foaf/0.1/homepage:
+      - "@value": https://greggkellogg.net
+      http://xmlns.com/foaf/0.1/depiction:
+      - "@value": http://www.gravatar.com/avatar/42f948adff3afaa52249d963117af7c8
+    )
+
+### Expand a YAML-LD Document to JSON-LD
+
+    input = StringIO.new(%(
+    "@context":
+      "@vocab": http://xmlns.com/foaf/0.1/
+    name: Gregg Kellogg
+    homepage: https://greggkellogg.net
+    depiction: http://www.gravatar.com/avatar/42f948adff3afaa52249d963117af7c8
+    ))
+
+    YAML_LD::API.expand(input, serializer: JSON::LD::API.method(:serializer)) # => %(
+    [
+      {
+        "http://xmlns.com/foaf/0.1/name": [{ "@value": "Gregg Kellogg" }],
+        "http://xmlns.com/foaf/0.1/homepage": [{ "@value": "https://greggkellogg.net" }],
+        "http://xmlns.com/foaf/0.1/depiction": [{
+          "@value": "http://www.gravatar.com/avatar/42f948adff3afaa52249d963117af7c8"
+        }]
+      }
+    ]
+    )
+
+### Expand a JSON-LD Document to YAML-LD
+
+    input = StringIO.new(%(
+    {
+      "@context": {
+        "@vocab":"http://xmlns.com/foaf/0.1/"
+      },
+      "name": "Gregg Kellogg",
+      "homepage": "https://greggkellogg.net",
+      "depiction": "http://www.gravatar.com/avatar/42f948adff3afaa52249d963117af7c8"
+    }
+    ))
+
+    YAML_LD::API.expand(input, content_type: 'application/ld+json') # => %(
+    %YAML 1.2
+    ---
+    - http://xmlns.com/foaf/0.1/name:
+      - "@value": Gregg Kellogg
+      http://xmlns.com/foaf/0.1/homepage:
+      - "@value": https://greggkellogg.net
+      http://xmlns.com/foaf/0.1/depiction:
+      - "@value": http://www.gravatar.com/avatar/42f948adff3afaa52249d963117af7c8
+      )
+
+## Implementation
+
+The gem largely acts as a front-end for the [JSON-LD gem][] with differences largely in the serialization format only.
+
+In addition to the input, both a `context` and `frame` may be specified using either JSON-LD or YAML-LD.
+
+## Dependencies
+* [Ruby](https://ruby-lang.org/) (>= 2.6)
+* [JSON-LD](https://rubygems.org/gems/json-ld) (>= 3.2.2)
+* [Psych](https://rubygems.org/gems/psych) (>= 4.0)
+* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.2)
+
+## Installation
+The recommended installation method is via [RubyGems](https://rubygems.org/).
+To install the latest official release of the `JSON-LD` gem, do:
+
+    % [sudo] gem install yaml-ld
+
+## Download
+To get a local working copy of the development repository, do:
+
+    % git clone git://github.com/ruby-rdf/yaml-ld.git
+
+## Mailing List
+* <https://lists.w3.org/Archives/Public/public-rdf-ruby/>
+
+## Author
+* [Gregg Kellogg](https://github.com/gkellogg) - <https://greggkellogg.net/>
+
+## Contributing
+* Do your best to adhere to the existing coding conventions and idioms.
+* Don't use hard tabs, and don't leave trailing whitespace on any line.
+* Do document every method you add using [YARD][] annotations. Read the
+  [tutorial][YARD-GS] or just look at the existing code for examples.
+* Don't touch the `json-ld.gemspec`, `VERSION` or `AUTHORS` files. If you need to
+  change them, do so on your private branch only.
+* Do feel free to add yourself to the `CREDITS` file and the corresponding
+  list in the the `README`. Alphabetical order applies.
+* Do note that in order for us to merge any non-trivial changes (as a rule
+  of thumb, additions larger than about 15 lines of code), we need an
+  explicit [public domain dedication][PDD] on record from you,
+  which you will be asked to agree to on the first commit to a repo within the organization.
+  Note that the agreement applies to all repos in the [Ruby RDF](https://github.com/ruby-rdf/) organization.
+
+## License
+
+This is free and unencumbered public domain software. For more information,
+see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
+
+[Ruby]:             https://ruby-lang.org/
+[RDF]:              https://www.w3.org/RDF/
+[YARD]:             https://yardoc.org/
+[YARD-GS]:          https://rubydoc.info/docs/yard/file/docs/GettingStarted.md
+[PDD]:              https://unlicense.org/#unlicensing-contributions
+[RDF.rb]:           https://rubygems.org/gems/rdf
+[JSON-LD gem]:          https://rubygems.org/gems/json-ld
+[JSON-LD]:          https://www.w3.org/TR/json-ld11/ "JSON-LD 1.1"
+[YAML-LD]:          https://json-ld.github.io/yaml-ld/spec/

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/yaml_ld/api.rb

@@ -0,0 +1,295 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+require 'json/ld/api'
+
+module YAML_LD
+  ##
+  # A YAML-LD processor based on JSON-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
+    LINK_TYPE_JSONLD = %w(type application/ld+yaml).freeze
+
+    ##
+    # Expands the given input according to the steps in the Expansion Algorithm. The input must be copied, expanded and returned if there are no errors. If the expansion fails, an appropriate exception must be thrown.
+    #
+    # The resulting `Array` either returned or yielded
+    #
+    # @param [String, #read, Hash, Array] input
+    #   The YAML-LD object to copy and perform the expansion upon.
+    # @param [Proc] documentLoader
+    #   The callback of the loader to be used to retrieve remote documents and contexts, and to parse IO objects.
+    #   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.
+    #   The remote document returned must be parsed if it is YAML.
+    # @param [Proc] serializer (nil)
+    #   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
+    # @raise [JsonLdError]
+    # @yield YAML_LD, base_iri
+    # @yieldparam [Array<Hash>] yamlld
+    #   The expanded YAML-LD document
+    # @yieldparam [RDF::URI
+    #   The document base as determined during expansion
+    # @yieldreturn [String] returned YAML serialization
+    # @return [String]
+    #   If a block is given, the result of evaluating the block is returned, otherwise, the expanded YAML-LD document
+    # @see https://www.w3.org/TR/json-ld11-api/#expansion-algorithm
+    def self.expand(input,
+                    documentLoader: self.method(:documentLoader),
+                    serializer: self.method(:serializer),
+                    **options,
+                    &block)
+      JSON::LD::API.expand(input,
+                           documentLoader: documentLoader, 
+                           serializer: serializer,
+                           **options,
+                           &block)
+    end
+
+    ##
+    # Compacts the given input according to the steps in the Compaction Algorithm. The input must be copied, compacted and returned if there are no errors. If the compaction fails, an appropirate exception must be thrown.
+    #
+    # If no context is provided, the input document is compacted using the top-level context of the document
+    #
+    # The resulting `Hash` is either returned or yielded, if a block is given.
+    #
+    # @param [String, #read, Hash, Array] input
+    #   The YAML-LD object to copy and perform the expansion upon.
+    # @param [String, #read, Hash, Array, JSON::LD::Context] context
+    #   The base context to use when compacting the input.
+    # @param [Proc] serializer (nil)
+    #   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 [Boolean] expanded (false) Input is already expanded
+    # @param  [Hash{Symbol => Object}] options
+    # @option options (see #initialize)
+    # @yield YAML_LD
+    # @yieldparam [Array<Hash>] yamlld
+    #   The expanded YAML-LD document
+    # @yieldreturn [String] returned YAML serialization
+    # @return [String]
+    #   If a block is given, the result of evaluating the block is returned, otherwise, the expanded YAML-LD document
+    # @raise [JsonLdError]
+    # @see https://www.w3.org/TR/json-ld11-api/#compaction-algorithm
+    def self.compact(input, context, expanded: false,
+                     documentLoader: self.method(:documentLoader),
+                     serializer: self.method(:serializer),
+                     **options,
+                     &block)
+      JSON::LD::API.compact(input, context, expanded: expanded,
+                           documentLoader: documentLoader, 
+                           serializer: serializer,
+                           **options,
+                           &block)
+    end
+
+    ##
+    # This algorithm flattens an expanded YAML-LD document by collecting all properties of a node in a single object and labeling all blank nodes with blank node identifiers. This resulting uniform shape of the document, may drastically simplify the code required to process YAML-LD data in certain applications.
+    #
+    # The resulting `Array` is either returned, or yielded if a block is given.
+    #
+    # @param [String, #read, Hash, Array] input
+    #   The YAML-LD object or array of JSON-LD objects to flatten or an IRI referencing the JSON-LD document to flatten.
+    # @param [String, #read, Hash, Array, JSON::LD::EvaluationContext] context
+    #   An optional external context to use additionally to the context embedded in input when expanding the input.
+    # @param [Boolean] expanded (false) Input is already expanded
+    # @param [Proc] serializer (nil)
+    #   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 [Boolean] :createAnnotations
+    #   Unfold embedded nodes which can be represented using `@annotation`.
+    # @yield YAML_LD
+    # @yieldparam [Array<Hash>] yamlld
+    #   The expanded YAML-LD document
+    # @yieldreturn [String] returned YAML serialization
+    # @return [Object, Hash]
+    #   If a block is given, the result of evaluating the block is returned, otherwise, the flattened JSON-LD document
+    # @see https://www.w3.org/TR/json-ld11-api/#framing-algorithm
+    def self.flatten(input, context, expanded: false,
+                     documentLoader: self.method(:documentLoader),
+                     serializer: self.method(:serializer),
+                     **options,
+                     &block)
+      JSON::LD::API.flatten(input, context, expanded: expanded,
+                            documentLoader: documentLoader, 
+                            serializer: serializer,
+                            **options,
+                            &block)
+    end
+
+    ##
+    # Frames the given input using the frame according to the steps in the Framing Algorithm. The input is used to build the framed output and is returned if there are no errors. If there are no matches for the frame, null must be returned. Exceptions must be thrown if there are errors.
+    #
+    # The resulting `Array` is either returned, or yielded if a block is given.
+    #
+    # @param [String, #read, Hash, Array] input
+    #   The YAML-LD object or array of YAML-LD objects to flatten or an IRI referencing the JSON-LD document to flatten.
+    # @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 ['@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] :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)
+    #   a flag specifying that properties that are missing from the JSON-LD input should be omitted from the output.
+    # @option options [Boolean] :pruneBlankNodeIdentifiers (true) removes blank node identifiers that are only used once.
+    # @option options [Boolean] :omitGraph does not use `@graph` at top level unless necessary to describe multiple objects, defaults to `true` if processingMode is 1.1, otherwise `false`.
+    # @yield YAML_LD
+    # @yieldparam [Array<Hash>] yamlld
+    #   The expanded YAML-LD document
+    # @yieldreturn [String] returned YAML serialization
+    # @return [Object, Hash]
+    #   If a block is given, the result of evaluating the block is returned, otherwise, the framed JSON-LD document
+    # @raise [InvalidFrame]
+    # @see https://www.w3.org/TR/json-ld11-api/#framing-algorithm
+    def self.frame(input, frame, expanded: false,
+                   documentLoader: self.method(:documentLoader),
+                   serializer: self.method(:serializer),
+                   **options,
+                   &block)
+      JSON::LD::API.frame(input, frame, expanded: expanded,
+                          documentLoader: documentLoader, 
+                          serializer: serializer,
+                          **options,
+                          &block)
+    end
+
+    ##
+    # Processes the input according to the RDF Conversion Algorithm, calling the provided callback for each triple generated.
+    #
+    # @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 [Boolean] :produceGeneralizedRdf (false)
+    #   If true, output will include statements having blank node predicates, otherwise they are dropped.
+    # @raise [JsonLdError]
+    # @yield statement
+    # @yieldparam [RDF::Statement] statement
+    # @return [RDF::Enumerable] set of statements, unless a block is given.
+    def self.toRdf(input, expanded: false,
+                   documentLoader: self.method(:documentLoader),
+                   **options,
+                   &block)
+      JSON::LD::API.toRdf(input, expanded: expanded,
+                          documentLoader: documentLoader, 
+                          **options,
+                          &block)
+    end
+    
+    ##
+    # Take an ordered list of RDF::Statements and turn them into a JSON-LD document.
+    #
+    # The resulting `Array` is either returned or yielded, if a block is given.
+    #
+    # @param [RDF::Enumerable] input
+    # @param [Boolean] useRdfType (false)
+    #   If set to `true`, the JSON-LD processor will treat `rdf:type` like a normal property instead of using `@type`.
+    # @param [Boolean] useNativeTypes (false) use native representations
+    # @param [Proc] serializer (nil)
+    #   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)
+    # @yield jsonld
+    # @yieldparam [Hash] jsonld
+    #   The JSON-LD document in expanded form
+    # @yieldreturn [Object] returned object
+    # @return [Object, Hash]
+    #   If a block is given, the result of evaluating the block is returned, otherwise, the expanded JSON-LD document
+    def self.fromRdf(input, useRdfType: false, useNativeTypes: false,
+                     documentLoader: self.method(:documentLoader),
+                     serializer: self.method(:serializer),
+                     **options,
+                     &block)
+      JSON::LD::API.fromRdf(input,
+                            useRdfType: useRdfType,
+                            useNativeTypes: useNativeTypes,
+                            documentLoader: documentLoader, 
+                            serializer: serializer,
+                            **options,
+                            &block)
+    end
+
+    ##
+    # Default document loader for YAML_LD.
+    # @param [RDF::URI, String] url
+    # @param [Boolean] extractAllScripts
+    #   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.
+    # @param [String] profile
+    #   When the resulting `contentType` is `text/html` or `application/xhtml+xml`, this option determines the profile to use for selecting a JSON-LD script elements.
+    # @param [String] requestProfile
+    #   One or more IRIs to use in the request as a profile parameter.
+    # @param [Hash<Symbol => Object>] options
+    # @yield remote_document
+    # @yieldparam [RemoteDocument, RDF::Util::File::RemoteDocument] remote_document
+    # @raise [IOError]
+    def self.documentLoader(url, extractAllScripts: false, profile: nil, requestProfile: nil, **options, &block)
+      if url.respond_to?(:read)
+        base_uri = options[:base]
+        base_uri ||= url.base_uri if url.respond_to?(:base_uri)
+        content_type = options[:content_type]
+        content_type ||= url.content_type if url.respond_to?(:content_type)
+        context_url = if url.respond_to?(:links) && url.links &&
+          # Any JSON type other than ld+json
+          (content_type == 'application/json' || content_type.match?(%r(application/(^ld)+json)))
+          link = url.links.find_link(JSON::LD::API::LINK_REL_CONTEXT)
+          link.href if link
+        elsif  url.respond_to?(:links) && url.links &&
+          # Any YAML type
+          content_type.match?(%r(application/(\w+\+)*yaml))
+          link = url.links.find_link(LINK_REL_CONTEXT)
+          link.href if link
+        end
+
+        content = case content_type
+        when nil, %r(application/(\w+\+)*yaml)
+          # Parse YAML
+          Psych.safe_load(url.read, aliases: true)
+        else
+          url.read
+        end
+        block.call(RemoteDocument.new(content,
+          documentUrl: base_uri,
+          contentType: content_type,
+          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),
+          documentUrl: base_uri,
+          contentType: content_type,
+          contextUrl: context_url))
+      else
+        RDF::Util::File.open_file(url, **options, &block)
+      end
+    end
+
+    ##
+    # The default serializer for serialzing Ruby Objects to JSON.
+    #
+    # Defaults to `MultiJson.dump`
+    #
+    # @param [Object] object
+    # @param [Array<Object>] args
+    #   other arguments that may be passed for some specific implementation.
+    # @param [Hash<Symbol, Object>] options
+    #   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)
+    end
+  end
+end
+

data/lib/yaml_ld/format.rb

@@ -0,0 +1,56 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+module YAML_LD
+  ##
+  # YAML-LD format specification.
+  #
+  # @example Obtaining an YAML-LD format class
+  #     RDF::Format.for(:YAML_LD)           #=> YAML_LD::Format
+  #     RDF::Format.for("etc/foaf.YAML_LD")
+  #     RDF::Format.for(:file_name         => "etc/foaf.YAML_LD")
+  #     RDF::Format.for(file_extension: "YAML_LD")
+  #     RDF::Format.for(:content_type   => "application/ld+yaml")
+  #
+  # @example Obtaining serialization format MIME types
+  #     RDF::Format.content_types      #=> {"application/ld+yaml" => [YAML_LD::Format],
+  #
+  # @example Obtaining serialization format file extension mappings
+  #     RDF::Format.file_extensions    #=> {:YAML_LD => [YAML_LD::Format] }
+  #
+  # @see https://json-ld.github.io/yaml-ld/spec/
+  # @see https://json-ld.github.io/yaml/tests/
+  class Format < RDF::Format
+    content_type     'application/ld+yaml',
+                     extension: :yamlld,
+                     uri: 'http://www.w3.org/ns/formats/YAML-LD'
+    content_encoding 'utf-8'
+
+    reader { YAML_LD::Reader }
+    writer { YAML_LD::Writer }
+
+    ##
+    # Sample detection to see if it matches YAML-LD
+    #
+    # Use a text sample to detect the format of an input file. Sub-classes implement
+    # a matcher sufficient to detect probably format matches, including disambiguating
+    # between other similar formats.
+    #
+    # @param [String] sample Beginning several bytes (~ 1K) of input.
+    # @return [Boolean]
+    def self.detect(sample)
+      !!sample.match(/---/m)
+    end
+
+    ##
+    # Override normal symbol generation
+    def self.to_sym
+      :yamlld
+    end
+
+    ##
+    # Override normal format name
+    def self.name
+      "YAML-LD"
+    end
+  end
+end

data/lib/yaml_ld/reader.rb

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+require 'json/ld/reader'
+
+module YAML_LD
+  ##
+  # A YAML-LD parser in Ruby.
+  class Reader < JSON::LD::Reader
+    format Format
+
+    ##
+    # Initializes the YAML-LD reader instance.
+    #
+    # @param  [IO, File, String]       input
+    # @param [Proc] documentLoader
+    #   The callback of the loader to be used to retrieve remote documents and contexts, and to parse IO objects.
+    #   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.
+    #   The remote document returned must be parsed if it is YAML.
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional options (see `RDF::Reader#initialize` and `JSON::LD::API.initialize`)
+    # @yield  [reader] `self`
+    # @yieldparam  [RDF::Reader] reader
+    # @yieldreturn [void] ignored
+    # @raise [RDF::ReaderError] if the JSON document cannot be loaded
+    def initialize(input = $stdin,
+      documentLoader: YAML_LD::API.method(:documentLoader),
+      **options, &block)
+      input = StringIO.new(input) if input.is_a?(String)
+      super(input, documentLoader: documentLoader, **options, &block)
+    end
+
+    ##
+    # @private
+    # @see   RDF::Reader#each_statement
+    def each_statement(&block)
+      API.toRdf(@doc, **@options, &block)
+    rescue ::Psych::SyntaxError, ::JSON::LD::JsonLdError => e
+      log_fatal("Failed to parse input document: #{e.message}", exception: RDF::ReaderError)
+    end
+  end
+end

data/lib/yaml_ld/version.rb

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+module YAML_LD::VERSION
+  VERSION_FILE = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "..", "VERSION")
+  MAJOR, MINOR, TINY, EXTRA = File.read(VERSION_FILE).chomp.split(".")
+
+  STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
+
+  ##
+  # @return [String]
+  def self.to_s()   STRING end
+
+  ##
+  # @return [String]
+  def self.to_str() STRING end
+
+  ##
+  # @return [Array(Integer, Integer, Integer)]
+  def self.to_a() STRING.split(".") end
+end

data/lib/yaml_ld/writer.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+require 'json/ld/writer'
+
+module YAML_LD
+  ##
+  # A YAML-LD serializer in Ruby.
+  class Writer < JSON::LD::Writer
+    ##
+    # Initializes the YAML-LD writer instance.
+    #
+    # @param  [IO, File] output
+    #   the output stream
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional options
+    # @option options [Encoding] :encoding     (Encoding::UTF_8)
+    #   the encoding to use on the output stream (Ruby 1.9+)
+    # @option options [Boolean]  :canonicalize (false)
+    #   whether to canonicalize literals when serializing
+    # @option options [Hash]     :prefixes     ({})
+    #   the prefix mappings to use (not supported by all writers)
+    # @option options [Boolean]  :standard_prefixes   (false)
+    #   Add standard prefixes to @prefixes, if necessary.
+    # @option options [IO, Array, Hash, String, Context]     :context     ({})
+    #   context to use when serializing. Constructed context for native serialization.
+    # @option options [IO, Array, Hash, String, Context]     :frame     ({})
+    #   frame to use when serializing.
+    # @option options [Boolean]  :unique_bnodes   (false)
+    #   Use unique bnode identifiers, defaults to using the identifier which the node was originall initialized with (if any).
+    # @option options [Proc] serializer (YAML_LD::API.serializer)
+    #   A Serializer method used for generating the YAML serialization of the result.
+    # @option options [Boolean] :stream (false)
+    #   Do not attempt to optimize graph presentation, suitable for streaming large graphs.
+    # @yield  [writer] `self`
+    # @yieldparam  [RDF::Writer] writer
+    # @yieldreturn [void]
+    # @yield  [writer]
+    # @yieldparam [RDF::Writer] writer
+    def initialize(output = $stdout, **options, &block)
+      super(output, **options.merge(serializer: YAML_LD::API.method(:serializer)), &block)
+    end
+  end
+end