yaml-ld 0.0.1

data/lib/yaml_ld.rb

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+$:.unshift(File.expand_path("../ld", __FILE__))
+require 'rdf' # @see https://rubygems.org/gems/rdf
+require 'json/ld'
+require 'psych'
+require 'yaml_ld/format'
+
+module YAML_LD
+  ##
+  # **`YAML_LD`** is a YAML-LD extension for RDF.rb.
+  #
+  # @example Requiring the `YAML_LD` module
+  #   require 'yaml_ld'
+  #
+  # @example Parsing RDF statements from a YAML-LD file
+  #   JSON::LD::Reader.open("etc/foaf.YAML_LD") do |reader|
+  #     reader.each_statement do |statement|
+  #       puts statement.inspect
+  #     end
+  #   end
+  #
+  # @see https://rubygems.org/gems/rdf
+  # @see http://www.w3.org/TR/REC-rdf-syntax/
+  #
+  # @note Classes and module use `YAML_LD` instead of `YAML_LD`, as `Psych` squats on the `YAML` module.
+  #
+  # @author [Gregg Kellogg](http://greggkellogg.net/)
+
+  autoload :API,                'yaml_ld/api'
+  autoload :Reader,             'yaml_ld/reader'
+  autoload :VERSION,            'yaml_ld/version'
+  autoload :Writer,             'yaml_ld/writer'
+
+  # YAML-LD profiles
+  YAML_LD_NS = "http://www.w3.org/ns/yaml-ld#"
+  PROFILES = %w(extended).map {|p| YAML_LD_NS + p}.freeze
+end

data/spec/api_spec.rb

@@ -0,0 +1,92 @@
+
+# coding: utf-8
+require_relative 'spec_helper'
+
+describe YAML_LD::API do
+  let(:logger) {RDF::Spec.logger}
+  before {JSON::LD::Context::PRELOADED.clear}
+
+  context "Test Files" do
+    %i(psych).each do |adapter|
+      Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), 'test-files/*-input.*'))) do |filename|
+        test = File.basename(filename).sub(/-input\..*$/, '')
+        frame = filename.sub(/-input\..*$/, '-frame.jsonld')
+        framed = filename.sub(/-input\..*$/, '-framed.jsonld')
+        compacted = filename.sub(/-input\..*$/, '-compacted.jsonld')
+        context = filename.sub(/-input\..*$/, '-context.jsonld')
+        expanded = filename.sub(/-input\..*$/, '-expanded.jsonld')
+        expanded_yaml = filename.sub(/-input\..*$/, '-expanded.yamlld')
+        ttl = filename.sub(/-input\..*$/, '-rdf.ttl')
+
+        context test do
+          around do |example|
+            @file = File.open(filename)
+            case filename
+            when /\.yamlld$/
+              @file.define_singleton_method(:content_type) {'application/ld+yaml'}
+            when /.jsonld$/
+              @file.define_singleton_method(:content_type) {'application/ld+json'}
+            end
+            if context
+              @ctx_io = File.open(context)
+              case context
+              when /\.yamlld$/
+                @ctx_io.define_singleton_method(:content_type) {'application/ld+yaml'}
+              when /.jsonld$/
+                @ctx_io.define_singleton_method(:content_type) {'application/ld+json'}
+              end
+            end
+            example.run
+            @file.close
+            @ctx_io.close if @ctx_io
+          end
+
+          if File.exist?(expanded)
+            it "expands" do
+              options = {logger: logger, adapter: adapter}
+              options[:expandContext] = @ctx_io if context
+              yaml = described_class.expand(@file, **options)
+              expect(yaml).to be_a(String)
+              parsed_json = JSON.parse(File.read(expanded))
+              expect(yaml).to produce_yamlld(parsed_json, logger)
+            end
+          end
+
+          if File.exist?(expanded_yaml)
+            it "expands to YAML" do
+              options = {logger: logger, adapter: adapter}
+              options[:expandContext] = @ctx_io if context
+              yaml = described_class.expand(@file, **options)
+              expect(yaml).to be_a(String)
+              expect(yaml).to produce_yamlld(YAML.load_file(expanded_yaml), logger)
+            end
+          end
+
+          if File.exist?(compacted) && File.exist?(context)
+            it "compacts" do
+              yaml = described_class.compact(@file, @ctx_io, adapter: adapter, logger: logger)
+              expect(yaml).to be_a(String)
+              parsed_json = JSON.parse(File.read(compacted))
+              expect(yaml).to produce_yamlld(parsed_json, logger)
+            end
+          end
+
+          if File.exist?(framed) && File.exist?(frame)
+            it "frames" do
+              File.open(frame) do |frame_io|
+                yaml = described_class.frame(@file, frame_io, adapter: adapter, logger: logger)
+                expect(yaml).to be_a(String)
+                parsed_json = JSON.parse(File.read(framed))
+                expect(yaml).to produce_yamlld(parsed_json, logger)
+              end
+            end
+          end
+
+          it "toRdf" do
+            expect(RDF::Repository.load(filename, format: :yamlld, adapter: adapter, logger: logger)).to be_equivalent_graph(RDF::Repository.load(ttl), logger: logger)
+          end if File.exist?(ttl)
+        end
+      end
+    end
+  end
+end

data/spec/compact_spec.rb

@@ -0,0 +1,358 @@
+# coding: utf-8
+require_relative 'spec_helper'
+
+describe YAML_LD::API do
+  let(:logger) {RDF::Spec.logger}
+
+  describe ".compact" do
+    {
+      "prefix" => {
+        input: %(---
+          "@id": http://example.com/a
+          http://example.com/b:
+            "@id": http://example.com/c
+        ),
+        context: %({"ex": "http://example.com/"}),
+        output: %(%YAML 1.2\n---
+          "@context":
+            ex: http://example.com/
+          "@id": ex:a
+          ex:b:
+            "@id": ex:c
+        )
+      },
+      "term" => {
+        input: %(---
+          "@id": http://example.com/a
+          http://example.com/b:
+            "@id": http://example.com/c
+        ),
+        context: %({"b": "http://example.com/b"}),
+        output: %(%YAML 1.2\n---
+          "@context":
+            b: http://example.com/b
+          "@id": http://example.com/a
+          b:
+            "@id": http://example.com/c
+        )
+      },
+      "integer value" => {
+        input: %(---
+          "@id": http://example.com/a
+          http://example.com/b:
+            "@value": 1
+        ),
+        context: %({"b": "http://example.com/b"}),
+        output: %(%YAML 1.2\n---
+          "@context":
+            b: http://example.com/b
+          "@id": http://example.com/a
+          b: 1
+        )
+      },
+      "boolean value" => {
+        input: %(---
+          "@id": http://example.com/a
+          http://example.com/b:
+            "@value": true
+        ),
+        context: %({"b": "http://example.com/b"}),
+        output: %(%YAML 1.2\n---
+          "@context":
+            b: http://example.com/b
+          "@id": http://example.com/a
+          b: true
+        )
+      },
+      "@id" => {
+        input: %(---
+          "@id": http://example.org/test#example
+        ),
+        context: {},
+        output: %{%YAML 1.2
+          --- {}
+        }
+      },
+      "@id coercion" => {
+        input: %({
+          "@id": "http://example.com/a",
+          "http://example.com/b": {"@id": "http://example.com/c"}
+        }),
+        context: %({"b": {"@id": "http://example.com/b", "@type": "@id"}}),
+        output: %(%YAML 1.2\n---
+          "@context":
+            b:
+              "@id": http://example.com/b
+              "@type": "@id"
+          "@id": http://example.com/a
+          b: http://example.com/c
+        )
+      },
+      "xsd:date coercion" => {
+        input: %(---
+          http://example.com/b:
+            "@value": '2012-01-04'
+            "@type": http://www.w3.org/2001/XMLSchema#date
+        ),
+        context: %({
+          "xsd": "http://www.w3.org/2001/XMLSchema#",
+          "b": {"@id": "http://example.com/b", "@type": "xsd:date"}
+        }),
+        output: %(%YAML 1.2\n---
+          "@context":
+            xsd: http://www.w3.org/2001/XMLSchema#
+            b:
+              "@id": http://example.com/b
+              "@type": xsd:date
+          b: '2012-01-04'
+        )
+      },
+      "default language" => {
+        input: %(---
+          http://example.com/term:
+          - v5
+          - "@value": plain literal
+        ),
+        context: %({
+          "term5": {"@id": "http://example.com/term", "@language": null},
+          "@language": "de"
+        }),
+        output: %(%YAML 1.2\n---
+          "@context":
+            term5:
+              "@id": http://example.com/term
+              "@language":
+            "@language": de
+          term5:
+          - v5
+          - plain literal
+        )
+      },
+      "default direction" => {
+        input: %(---
+          http://example.com/term:
+          - v5
+          - "@value": plain literal
+        ),
+        context: %({
+          "term5": {"@id": "http://example.com/term", "@direction": null},
+          "@direction": "ltr"
+        }),
+        output: %(%YAML 1.2\n---
+          "@context":
+            term5:
+              "@id": http://example.com/term
+              "@direction":
+            "@direction": ltr
+          term5:
+          - v5
+          - plain literal
+        )
+      },
+    }.each_pair do |title, params|
+      it(title) {run_compact(params)}
+    end
+
+    context "with @type: @json" do
+      {
+        "true": {
+          output: %(%YAML 1.2\n---
+            "@context":
+              "@version": 1.1
+              e:
+                "@id": http://example.org/vocab#bool
+                "@type": "@json"
+            e: true
+          ),
+          input:%(
+            - http://example.org/vocab#bool:
+              - "@value": true
+                "@type": "@json"
+          ),
+        },
+        "false": {
+          output: %(%YAML 1.2\n---
+            "@context":
+              "@version": 1.1
+              e:
+                "@id": http://example.org/vocab#bool
+                "@type": "@json"
+            e: false
+          ),
+          input:%(
+            - http://example.org/vocab#bool:
+              - "@value": false
+                "@type": "@json"
+          )
+        },
+        "double": {
+          output: %(%YAML 1.2\n---
+            "@context":
+              "@version": 1.1
+              e:
+                "@id": http://example.org/vocab#double
+                "@type": "@json"
+            e: 1.23
+          ),
+          input:%(
+            - http://example.org/vocab#double:
+              - "@value": 1.23
+                "@type": "@json"
+          )
+        },
+        "double-zero": {
+          output: %(%YAML 1.2\n---
+            "@context":
+              "@version": 1.1
+              e:
+                "@id": http://example.org/vocab#double
+                "@type": "@json"
+            e: 0.0e0
+          ),
+          input:%(
+            - http://example.org/vocab#double:
+              - "@value": 0.0e0
+                "@type": "@json"
+          )
+        },
+        "integer": {
+          output: %(%YAML 1.2\n---
+            "@context":
+              "@version": 1.1
+              e:
+                "@id": http://example.org/vocab#integer
+                "@type": "@json"
+            e: 123
+          ),
+          input:%(
+            - http://example.org/vocab#integer:
+              - "@value": 123
+                "@type": "@json"
+          )
+        },
+        "string": {
+          output: %(%YAML 1.2\n---
+            "@context":
+              "@version": 1.1
+              e:
+                "@id": http://example.org/vocab#string
+                "@type": "@json"
+            e: string
+          ),
+          input:%(
+            - http://example.org/vocab#string:
+              - "@value": string
+                "@type": "@json"
+          )
+        },
+        "null": {
+          output: %(%YAML 1.2\n---
+            "@context":
+              "@version": 1.1
+              e:
+                "@id": http://example.org/vocab#null
+                "@type": "@json"
+            e:
+          ),
+          input:%(
+            - http://example.org/vocab#null:
+              - "@value": null
+                "@type": "@json"
+          )
+        },
+        "object": {
+          output: %(%YAML 1.2\n---
+            "@context":
+              "@version": 1.1
+              e:
+                "@id": http://example.org/vocab#object
+                "@type": "@json"
+            e:
+              foo: bar
+          ),
+          input:%(
+            - http://example.org/vocab#object:
+              - "@value":
+                  foo: bar
+                "@type": "@json"
+          )
+        },
+        "array": {
+          output: %(%YAML 1.2\n---
+            "@context":
+              "@version": 1.1
+              e:
+                "@id": http://example.org/vocab#object
+                "@type": "@json"
+            e:
+            - foo
+            - bar
+          ),
+          input:%(
+            - http://example.org/vocab#object:
+              - "@value": [foo, bar]
+                "@type": "@json"
+          )
+        },
+        "Already expanded object": {
+          output: %(%YAML 1.2\n---
+            "@context":
+              "@version": 1.1
+            http://example.org/vocab#object:
+              "@value":
+                foo: bar
+              "@type": "@json"
+          ),
+          input:%(
+            - http://example.org/vocab#object:
+              - "@value": {foo: bar}
+                "@type": "@json"
+          )
+        },
+        "Already expanded object with aliased keys": {
+          output: %(%YAML 1.2\n---
+            "@context":
+              "@version": 1.1
+              value: "@value"
+              type: "@type"
+              json: "@json"
+            http://example.org/vocab#object:
+              value:
+                foo: bar
+              type: json
+          ),
+          input:%(
+            - http://example.org/vocab#object:
+              - "@value": {foo: bar}
+                "@type": "@json"
+          )
+        },
+      }.each do |title, params|
+        it(title) {run_compact(processingMode: 'json-ld-1.1', **params)}
+      end
+    end
+  end
+
+  def run_compact(params)
+    input, output, context = params[:input], params[:output], params[:context]
+    params[:base] ||= nil
+    context ||= output  # Since it will have the context
+    input = StringIO.new(input.unindent) if input.is_a?(String)
+    input.define_singleton_method(:content_type) {'application/ld+yaml'}
+    context = Psych.safe_load(context.unindent, aliases: true) if context.is_a?(String)
+    context = context['@context'] if context.key?('@context')
+    pending params.fetch(:pending, "test implementation") unless input
+    if params[:exception]
+      expect {YAML_LD::API.compact(input, context, logger: logger, **params)}.to raise_error(params[:exception])
+    else
+      yaml = nil
+      if params[:write]
+        expect{yaml = YAML_LD::API.compact(input, context, logger: logger, **params)}.to write(params[:write]).to(:error)
+      else
+        expect{yaml = YAML_LD::API.compact(input, context, logger: logger, **params)}.not_to write.to(:error)
+      end
+
+      expect(yaml.strip).to eq output.unindent.strip
+    end
+  end
+end