yarspg 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b2b77d4c266d555c6bd1174dee2f8b8d789126ab66cde6a5f6abcdb92e6ae676
+  data.tar.gz: 5b1db8e4c1b65605d5aaeb285281dd1b070d90934c7dce9da0a8d2e067f57c80
+SHA512:
+  metadata.gz: b561d143b1d75f9d8eed956546d77bd50a2dcaa2f37503fa0522ebfc3919c25d5d5c268493f31e3117157f14726e9d9b8f5fb601c6bd8d6c30893498bd0f2807
+  data.tar.gz: 775e173535e0bb258ef233db97f63cf4aafa8988869bfb1264136e93314256532b2f306dd980b4859f3b9244f111a3b6e606ea920cda2ec06632fdf6a0302658

data/README.md

@@ -0,0 +1,152 @@
+# YARS-PG Property Graph to RDF* Processor.
+
+[YARS-PG][] reader for [RDF.rb][]. Reads [Property Graph][] descriptions and generates [RDF*][] datasets.
+
+[![Gem Version](https://badge.fury.io/rb/yarspg.png)](https://badge.fury.io/rb/yarspg)
+[![Build Status](https://secure.travis-ci.org/gkellogg/yarspg.png?branch=master)](https://travis-ci.org/gkellogg/yarspg)
+[![Coverage Status](https://coveralls.io/repos/gkellogg/yarspg/badge.svg)](https://coveralls.io/r/gkellogg/yarspg)
+
+## Features
+
+YARSPG parses CSV or other Tabular Data into [RDF*][].
+
+* Nodes, properties, and string annotations are treated as document-relative fragments.
+* Edges are emitted only to the default graph, with properties and annotations emitted either to the default graph, or the specifically named graph(s).
+* Node labels are treated as as document-relative `rdf:type` values.
+* List complex values are emitted as `rdf:Lists`.
+* Set and Struct complex values are emitted as `rdf:JSON` literals.
+
+## Installation
+Install with `gem install yarspg`.
+
+## Description
+
+YARSPG parses [YARS-PG][] formatted documents into [RDF*][] datasets, where edges are RDF triples in the default graph, which form the subject of the properties and annotations on that edge.
+
+There is currently no extra support for [Node Schemas](https://lszeremeta.github.io/yarspg/index.html#dfn-node-schema-declaration) or [Edge Schemas](https://lszeremeta.github.io/yarspg/index.html#dfn-edge-schema-declaration).
+
+## Example
+
+An example YARS-PG document follows:
+
+    # Prefix declaration
+    :foaf: <http://xmlns.com/foaf/0.1/>
+
+    %METADATA
+    -foaf:maker: "Łukasz Szeremeta and Dominik Tomaszuk"
+
+    %NODES
+    <"Author01">{"Author"}["fname": "John", "lname": "Smith"] #Author01
+    <"Author02">{"Author"}["fname": "Alice", "lname": "Brown"]
+    <"EI01">{"Entry", "InProceedings"}["title": "Serialization for...", "numpages": 10, "keyword": "Graph database"]
+    <"EA01">{"Entry", "Article"}["title": "Property Graph...",  "numpages": 10, "keyword": ["Query", "Graph"]]
+    <"Proc01">{"Proceedings"}["title": "BDAS", "year": 2018, "month": "May"]
+    <"Jour01">{"Journal"}["title": "J. DB", "year": 2020, "vol": 30]
+
+    %EDGES
+    ("EI01")-{"has_author"}["order": 1]->("Author01")
+    ("EI01")-{"has_author"}["order": 2]->("Author02")
+    ("EA01")-{"has_author"}["order": 1]->("Author02")
+    ("EA01")-{"cites"}->("EI01")
+    ("EI01")-{"booktitle"}["pages": "111-121"]->("Proc01")
+    ("EA01")-{"published_in"}["pages": "222-232"]->("Jour01")
+
+This results in the following TriG*:
+
+    @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+    @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+    @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+    <> foaf:maker "Łukasz Szeremeta and Dominik Tomaszuk" .
+
+    <#Author01> a <#Author>; <#fname> "John"; <#lname> "Smith" .
+    <#Author02> a <#Author>; <#fname> "Alice"; <#lname> "Brown" .
+
+    <#EI01> a <#Entry>, <#InProceedings>;
+      <#title> "Serialization for...";
+      <#numpages> 10;
+      <#keyword> "Graph database";
+      <#booktitle> <#Proc01>;
+      <#has_author> <#Author02>, <#Author01> .
+
+    <#EA01> a <#Entry>, <#Article>;
+      <#title> "Property Graph...";
+      <#numpages> 10;
+      <#keyword> ("Query" "Graph");
+      <#cites> <#EI01>;
+      <#has_author> <#Author02>;
+      <#published_in> <#Jour01> .
+
+    <#Proc01> a <#Proceedings>;
+      <#month> "May";
+      <#title> "BDAS";
+      <#year> 2018 .
+
+    <#Jour01> a <#Journal>;
+      <#title> "J. DB";
+      <#vol> 30;
+      <#year> 2020 .
+
+    <<<#EI01> <#has_author> <#Author01>>> <#order> 1 .
+    <<<#EI01> <#has_author> <#Author02>>> <#order> 2 .
+    <<<#EA01> <#has_author> <#Author02>>> <#order> 1 .
+    <<<#EI01> <#booktitle> <#Proc01>>> <#pages> "111-121" .
+    <<<#EA01> <#published_in> <#Jour01>>> <#pages> "222-232" .
+
+## RDF Reader
+YARS acts as a normal RDF reader, using the standard RDF.rb Reader interface:
+
+    graph = RDF::Graph.load("etc/doap.yarspg")
+
+alternatively
+
+    graph = RDF::Graph.new {|g| YARSPG::Reader.open("etc/doap.yarspg") {|r| g << r}}
+
+### Principal Classes
+* {YARSPG}
+  * {YARSPG::Format}
+  * {YARSPG::Metadata}
+  * {YARSPG::Reader}
+  * {YARSPG::Terminals}
+
+## Dependencies
+* [Ruby](https://ruby-lang.org/) (>= 2.4)
+* [RDF.rb][] (~> 3.1)
+* [EBNF][] (~> 2.0)
+
+## Installation
+The recommended installation method is via [RubyGems](https://rubygems.org/).
+To install the latest official release of the `RDF::Tabular` gem, do:
+
+    % [sudo] gem install yarspg
+
+## 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 `rdf-tabular.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.
+
+##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://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
+[EBNF]:           https://rubygems.org/gems/ebnf
+[RDF.rb]:         https://rubygems.org/gems/rdf
+[RDF*]:           https://lists.w3.org/Archives/Public/public-rdf-star/
+[YARS-PG]:        https://lszeremeta.github.io/yarspg/index.html
+[Property Graph]: http://graphdatamodeling.com/Graph%20Data%20Modeling/GraphDataModeling/page/PropertyGraphs.html

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/yarspg.rb

@@ -0,0 +1,25 @@
+require 'rdf'
+
+##
+# **`YARSPG`** is an YARS-PG extension for RDF.rb.
+#
+# @example Requiring the `YARSPG` module
+#   require 'yarspg'
+#
+# @example Parsing statements from a YARS-PG file into a graph using RDF*.
+#   YARSPG::Reader.open("etc/foaf.yarspg") do |reader|
+#     reader.each_statement do |statement|
+#       puts statement.inspect
+#     end
+#   end
+#
+# @see https://rubydoc.info/github/ruby-rdf/rdf/
+# @see https://lszeremeta.github.io/yarspg/index.html
+#
+# @author [Gregg Kellogg](https://greggkellogg.net/)
+module YARSPG
+  require  'yarspg/format'
+  autoload :Reader,         'yarspg/reader'
+  autoload :VERSION,        'yarspg/version'
+  autoload :Writer,         'yarspg/writer'
+end

data/lib/yarspg/format.rb

@@ -0,0 +1,42 @@
+module YARSPG
+  ##
+  # YARS-PG format specification.
+  #
+  # @example Obtaining an ## format class
+  #     RDF::Format.for("etc/foaf.yarspg")
+  #     RDF::Format.for(file_name:      "etc/foaf.yarspg")
+  #     RDF::Format.for(file_extension: "yarspg")
+  #     RDF::Format.for(content_type:   "text/yarspg")
+  #
+  # @example Obtaining serialization format MIME types
+  #     RDF::Format.content_types      #=> {"text/yarspg" => [YARSPG::Format]}
+  #
+  # @example Obtaining serialization format file extension mappings
+  #     RDF::Format.file_extensions    #=> {yarspg: "text/yarspg"}
+  #
+  # @see https://www.w3.org/TR/rdf-testcases/#ntriples
+  class Format < RDF::Format
+    content_type     'text/yarspg',
+                     extension: :yarspg
+    content_encoding 'utf-8'
+
+    reader { YARSPG::Reader }
+    writer { YARSPG::Writer }
+
+    ##
+    # Sample detection to see if it matches YARS-PG
+    #
+    # 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(%r(
+        (?:%(METADATA|NODE SCHEMAS|EDGE SCHEMAS|NODES|EDGES)) | # Section Names
+        (?:[S\{.*\}]-)                                        | # Node Schema
+        (?:[S\(.*\)]-)                                        | # Edge Schema
+        (?:\(.*\)-)                                             # Edge
+      )mx)
+    end
+  end
+end

data/lib/yarspg/meta.rb

@@ -0,0 +1,176 @@
+# This file is automatically generated by ebnf version 2.0.0
+# Derived from etc/yars-pg.ebnf
+module YARSPG::Meta
+  RULES = [
+    EBNF::Rule.new(:yarspg, "1", [:star, :statement]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:statement, "2", [:alt, :node, :edge, :prefix_directive, :metadata, :node_schema, :edge_schema, :section]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:prefix_directive, "3", [:seq, :_prefix_directive_1, :IRI]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_prefix_directive_1, "3.1", [:alt, "::", :pname]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:pname, "4", [:seq, ":", :ALNUM_PLUS, ":"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:pn_local, "5", [:seq, :ALNUM_PLUS]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:metadata, "6", [:seq, "-", :_metadata_1, :_metadata_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_metadata_1, "6.1", [:alt, :_metadata_3, :_metadata_4]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_metadata_3, "6.3", [:seq, :pn_local, :pname]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_metadata_4, "6.4", [:seq, :IRI, ":"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_metadata_2, "6.2", [:alt, :STRING, :IRI]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:graph_name, "6a", [:seq, :STRING]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:annotation, "7", [:alt, :string_annotation, :rdf_annotation]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:string_annotation, "8", [:seq, :STRING, ":", :STRING]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:rdf_annotation, "9", [:seq, :_rdf_annotation_1, :_rdf_annotation_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_rdf_annotation_1, "9.1", [:alt, :_rdf_annotation_3, :_rdf_annotation_4]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_rdf_annotation_3, "9.3", [:seq, :pn_local, :pname]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_rdf_annotation_4, "9.4", [:seq, :IRI, ":"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_rdf_annotation_2, "9.2", [:alt, :STRING, :IRI]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:annotations_list, "10", [:seq, "+", :annotation, :_annotations_list_1]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_annotations_list_1, "10.1", [:star, :_annotations_list_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_annotations_list_2, "10.2", [:seq, ",", :annotation]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:props_list, "11", [:seq, "[", :prop, :_props_list_1, "]"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_props_list_1, "11.1", [:star, :_props_list_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_props_list_2, "11.2", [:seq, ",", :prop]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:graphs_list, "12", [:seq, "/", :graph_name, :_graphs_list_1, "/"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_graphs_list_1, "12.1", [:star, :_graphs_list_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_graphs_list_2, "12.2", [:seq, ",", :graph_name]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:node, "13", [:seq, "<", :node_id, ">", :_node_1, :_node_2, :_node_3, :_node_4]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_node_1, "13.1", [:opt, :_node_5]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_node_5, "13.5", [:seq, "{", :node_label, :_node_6, "}"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_node_6, "13.6", [:star, :_node_7]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_node_7, "13.7", [:seq, ",", :node_label]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_node_2, "13.2", [:opt, :props_list]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_node_3, "13.3", [:opt, :graphs_list]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_node_4, "13.4", [:opt, :annotations_list]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:edge, "14", [:alt, :directed, :undirected]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:section, "15", [:seq, "%", :SECTION_NAME]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:directed, "16", [:seq, "(", :node_id, ")", "-", :_directed_1, "{", :edge_label, "}", :_directed_2, "->", "(", :node_id, ")", :_directed_3, :_directed_4]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_directed_1, "16.1", [:opt, :_directed_5]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_directed_5, "16.5", [:seq, "<", :edge_id, ">"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_directed_2, "16.2", [:opt, :props_list]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_directed_3, "16.3", [:opt, :graphs_list]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_directed_4, "16.4", [:opt, :annotations_list]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:undirected, "17", [:seq, "(", :node_id, ")", "-", :_undirected_1, "{", :edge_label, "}", :_undirected_2, "-", "(", :node_id, ")", :_undirected_3, :_undirected_4]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_undirected_1, "17.1", [:opt, :_undirected_5]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_undirected_5, "17.5", [:seq, "<", :edge_id, ">"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_undirected_2, "17.2", [:opt, :props_list]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_undirected_3, "17.3", [:opt, :graphs_list]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_undirected_4, "17.4", [:opt, :annotations_list]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:node_id, "18", [:seq, :STRING]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:node_label, "19", [:seq, :STRING]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:prop, "20", [:seq, :key, ":", :value]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:edge_id, "21", [:seq, :STRING]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:edge_label, "22", [:seq, :STRING]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:key, "23", [:seq, :STRING]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:value, "24", [:alt, :primitive_value, :complex_value]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:primitive_value, "25", [:alt, :STRING, :DATETYPE, :NUMBER, :BOOL, "null"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:complex_value, "26", [:alt, :set, :list, :struct]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:set, "27", [:seq, "{", :_set_1, :_set_2, "}"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_set_1, "27.1", [:alt, :primitive_value, :set]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_set_2, "27.2", [:star, :_set_3]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_set_3, "27.3", [:seq, ",", :_set_4]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_set_4, "27.4", [:alt, :primitive_value, :set]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:list, "28", [:seq, "[", :_list_1, :_list_2, "]"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_list_1, "28.1", [:alt, :primitive_value, :list]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_list_2, "28.2", [:star, :_list_3]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_list_3, "28.3", [:seq, ",", :_list_4]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_list_4, "28.4", [:alt, :primitive_value, :list]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:struct, "29", [:seq, "{", :key, ":", :_struct_1, :_struct_2, "}"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_struct_1, "29.1", [:alt, :primitive_value, :struct]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_struct_2, "29.2", [:star, :_struct_3]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_struct_3, "29.3", [:seq, ",", :key, ":", :_struct_4]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_struct_4, "29.4", [:alt, :primitive_value, :struct]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:node_schema, "30", [:seq, "S", :_node_schema_1, :_node_schema_2, :_node_schema_3, :_node_schema_4]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_node_schema_1, "30.1", [:seq, "{", :node_label, :_node_schema_5, "}"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_node_schema_5, "30.5", [:star, :_node_schema_6]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_node_schema_6, "30.6", [:seq, ",", :node_label]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_node_schema_2, "30.2", [:opt, :props_list_schema]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_node_schema_3, "30.3", [:opt, :graphs_list]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_node_schema_4, "30.4", [:opt, :annotations_list]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:props_list_schema, "31", [:seq, "[", :prop_schema, :_props_list_schema_1, "]"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_props_list_schema_1, "31.1", [:star, :_props_list_schema_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_props_list_schema_2, "31.2", [:seq, ",", :prop_schema]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:prop_schema, "32", [:seq, :key, ":", :value_schema]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:value_schema, "33", [:alt, :primitive_value_schema, :complex_value_schema]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:primitive_value_schema, "34", [:alt, "Decimal", "SmallInt", "Integer", "BigInt", "Float", "Real", "Double", "Bool", "Null", "String", "Date", "Timestamp", "Time"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:complex_value_schema, "35", [:alt, :set_schema, :list_schema, :struct_schema]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:set_schema, "36", [:seq, "Set", "(", :_set_schema_1, ")"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_set_schema_1, "36.1", [:alt, :primitive_value_schema, :set_schema]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:list_schema, "37", [:seq, "List", "(", :_list_schema_1, ")"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_list_schema_1, "37.1", [:alt, :primitive_value_schema, :list_schema]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:struct_schema, "38", [:seq, "Struct", "(", :_struct_schema_1, ")"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_struct_schema_1, "38.1", [:alt, :primitive_value_schema, :struct_schema]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:edge_schema, "39", [:alt, :directed_schema, :undirected_schema]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:directed_schema, "40", [:seq, "S", :_directed_schema_1, "-", "{", :edge_label, "}", :_directed_schema_2, "->", :_directed_schema_3]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_directed_schema_1, "40.1", [:opt, :_directed_schema_4]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_directed_schema_4, "40.4", [:seq, "(", :node_label, ")"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_directed_schema_2, "40.2", [:opt, :props_list_schema]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_directed_schema_3, "40.3", [:opt, :_directed_schema_5]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_directed_schema_5, "40.5", [:seq, "(", :node_label, ")"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:undirected_schema, "41", [:seq, "S", :_undirected_schema_1, "-", "{", :edge_label, "}", :_undirected_schema_2, "-", :_undirected_schema_3]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_undirected_schema_1, "41.1", [:opt, :_undirected_schema_4]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_undirected_schema_4, "41.4", [:seq, "(", :node_label, ")"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_undirected_schema_2, "41.2", [:opt, :props_list_schema]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_undirected_schema_3, "41.3", [:opt, :_undirected_schema_5]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_undirected_schema_5, "41.5", [:seq, "(", :node_label, ")"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:SECTION_NAME, "42", [:alt, "METADATA", "NODE SCHEMAS", "EDGE SCHEMAS", "NODES", "EDGES"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:COMMENT, "43", [:seq, "#", :_COMMENT_1], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_COMMENT_1, "43.1", [:star, :_COMMENT_2], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_COMMENT_2, "43.2", [:range, "^#xd#xa#xc"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:STRING, "44", [:seq, :STRING_LITERAL_QUOTE], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:NUMBER, "45", [:seq, :_NUMBER_1, :_NUMBER_2, :_NUMBER_3, :_NUMBER_4], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_NUMBER_1, "45.1", [:opt, :SIGN], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_NUMBER_2, "45.2", [:plus, :_NUMBER_5], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_NUMBER_5, "45.5", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_NUMBER_3, "45.3", [:opt, "."], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_NUMBER_4, "45.4", [:star, :_NUMBER_6], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_NUMBER_6, "45.6", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:BOOL, "46", [:alt, "true", "false"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:STRING_LITERAL_QUOTE, "47", [:seq, "\"", :_STRING_LITERAL_QUOTE_1, "\""], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_STRING_LITERAL_QUOTE_1, "47.1", [:star, :_STRING_LITERAL_QUOTE_2], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_STRING_LITERAL_QUOTE_2, "47.2", [:alt, :_STRING_LITERAL_QUOTE_3, "'", "\""], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_STRING_LITERAL_QUOTE_3, "47.3", [:range, "^\"#xd#xa"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:ALNUM_PLUS, "48", [:seq, :PN_CHARS_BASE, :_ALNUM_PLUS_1], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_ALNUM_PLUS_1, "48.1", [:opt, :_ALNUM_PLUS_2], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_ALNUM_PLUS_2, "48.2", [:seq, :_ALNUM_PLUS_3, :PN_CHARS], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_ALNUM_PLUS_3, "48.3", [:star, :_ALNUM_PLUS_4], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_ALNUM_PLUS_4, "48.4", [:alt, :PN_CHARS, "."], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:IRI, "49", [:seq, "<", :_IRI_1, ">"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_IRI_1, "49.1", [:star, :_IRI_2], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_IRI_2, "49.2", [:alt, :PN_CHARS, ".", ":", "/", "\\", "#", "@", "%", "&", :UCHAR], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:PN_CHARS, "50", [:alt, :PN_CHARS_U, :_PN_CHARS_1], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_PN_CHARS_1, "50.1", [:range, "-0-9#xB7#x0300-#x036F#x203F-#x2040"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:PN_CHARS_U, "51", [:alt, :PN_CHARS_BASE, "_"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:DATETYPE, "52", [:alt, :TIMESTAMP, :DATE, :TIME], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:DATE, "53", [:seq, :_DATE_1, :_DATE_2, :_DATE_3, :_DATE_4, "-", :_DATE_5, :_DATE_6, "-", :_DATE_7, :_DATE_8], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_DATE_1, "53.1", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_DATE_2, "53.2", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_DATE_3, "53.3", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_DATE_4, "53.4", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_DATE_5, "53.5", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_DATE_6, "53.6", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_DATE_7, "53.7", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_DATE_8, "53.8", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:TIME, "54", [:seq, :_TIME_1, :_TIME_2, ":", :_TIME_3, :_TIME_4, ":", :_TIME_5, :_TIME_6, :_TIME_7], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_TIME_1, "54.1", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_TIME_2, "54.2", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_TIME_3, "54.3", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_TIME_4, "54.4", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_TIME_5, "54.5", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_TIME_6, "54.6", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_TIME_7, "54.7", [:opt, :TIMEZONE], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:TIMEZONE, "55", [:seq, :_TIMEZONE_1, :_TIMEZONE_2, :_TIMEZONE_3, ":", :_TIMEZONE_4, :_TIMEZONE_5], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_TIMEZONE_1, "55.1", [:opt, :SIGN], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_TIMEZONE_2, "55.2", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_TIMEZONE_3, "55.3", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_TIMEZONE_4, "55.4", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_TIMEZONE_5, "55.5", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:TIMESTAMP, "56", [:seq, :DATE, "T", :TIME], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:SIGN, "57", [:alt, "+", "-"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:UCHAR, "58", [:seq, :_UCHAR_1, :HEX, :HEX, :HEX, :HEX], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_UCHAR_1, "58.1", [:alt, "u", :_UCHAR_2], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_UCHAR_2, "58.2", [:seq, "U", :HEX, :HEX, :HEX, :HEX], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:PN_CHARS_BASE, "59", [:range, "A-Za-z0-9#xC0-#xD6#xD8-#xF6#xF8-#x2FF#x370-#x37D#x37F-#x1FFF#x200C-#x200D#x2070-#x218F#x2C00-#x2FEF#x3001-#xD7FF#xF900-#xFDCF#xFDF0-#xFFFD"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:HEX, "60", [:range, "0-9A-Fa-f"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:WS, "61", [:plus, :_WS_1], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_WS_1, "61.1", [:alt, :_WS_2, :COMMENT], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_WS_2, "61.2", [:range, "#x20#x9#xa"], kind: :terminal).extend(EBNF::PEG::Rule),
+  ]
+end
+

data/lib/yarspg/reader.rb

@@ -0,0 +1,413 @@
+# coding: utf-8
+require 'ebnf'
+require 'yarspg/meta'
+require 'yarspg/terminals'
+require 'json/canonicalization'
+
+module YARSPG
+  ##
+  # A parser for YARS-PG.
+  #
+  # Parses into RDF*, taking liberties with the meaning of a Property Graph.
+  #
+  # Issues:
+  #   * Is it an error to parse data outside of a declared section? (warning?)
+  #   * Node lables are treated like types
+  #   * Node properties are treated like statements on that node
+  #   * Node string annotations are treated like statements with the predicate created as a document fragment.
+  #   * Edge labels and Edge ids are ignored.
+  #   * The `graph_name` of each edge is used only for properties and annotations, the edges themselves are in the default graph (per RDF* semantics).
+  #   * Node and Edge schemas are ignored.
+
+  class Reader < RDF::Reader
+    format Format
+    include EBNF::PEG::Parser
+    include YARSPG::Meta
+    include YARSPG::Terminals
+    include RDF::Util::Logger
+
+    SECTION_ORDERS = {
+      METADATA:       0,
+      "NODE SCHEMAS": 1,
+      "EDGE SCHEMAS": 2,
+      NODES:          3,
+      EDGES:          4
+    }
+
+    PartialStatement = Struct.new(:predicate, :object)
+
+    # Terminial definitions
+
+    # Always return a literal, to distinguish between actual string terminals.
+    terminal(:STRING,        STRING) {|value| RDF::Literal(value[1..-2])}
+    terminal(:NUMBER,        NUMBER) do |value|
+      value.include?('.') ?
+        RDF::Literal::Decimal.new(value) :
+        RDF::Literal::Integer.new(value)
+    end
+
+    terminal(:BOOL,          BOOL) {|value| RDF::Literal::Boolean.new(value)}
+    terminal(:ALNUM_PLUS,    ALNUM_PLUS)
+    terminal(:IRI,           IRI) { |value| base_uri.join(value[1..-2])}
+    terminal(:DATE,          DATE) {|value| RDF::Literal::Date.new(value)}
+    terminal(:TIME,          TIME) {|value| RDF::Literal::Time.new(value)}
+    terminal(:TIMESTAMP,     TIMESTAMP) {|value| RDF::Literal::DateTime.new(value)}
+
+    # `[3]   prefix_directive  ::= ('::' | pname) IRI`
+    production(:prefix_directive) do |value, data, callback|
+      if value.first[:_prefix_directive_1] == '::'
+        callback.call(:base_uri, value.last[:IRI])
+      else
+        pfx = value.first[:_prefix_directive_1].to_sym
+        prefixes[pfx] = value.last[:IRI]
+      end
+    end
+
+    # `[4]   pname ::= ":" ALNUM_PLUS ":"`
+    production(:pname) {|value| value[1][:ALNUM_PLUS]}
+
+    # `[5]   pn_local  ::= ALNUM_PLUS`
+    #
+    # This must be a prefix
+    production(:pn_local) do |value|
+      pfx = value.first[:ALNUM_PLUS].to_sym
+      error("pn_local", "no prefix defined for #{pfx}") unless prefixes[pfx]
+      prefixes[pfx]
+    end
+
+    # `[6]   metadata  ::= "-" ((pn_local pname) | (IRI ":")) (STRING | IRI)`
+    production(:metadata) do |value, data, callback|
+      pred = value[1][:_metadata_1]
+      obj = value[2][:_metadata_2]
+      callback.call(:statement, :metadata, base_uri, pred, obj)
+      nil
+    end
+    # `(seq pn_local pname)`
+    production(:_metadata_3) {|value| value.first[:pn_local].join(value.last[:pname])}
+    # `(seq IRI ":")`
+    production(:_metadata_4) {|value| value.first[:IRI]}
+
+    # `[6a]  graph_name ::= STRING`
+    production(:graph_name) {|value| base_uri.join("##{value.first[:STRING]}")}
+
+    production(:annotation) {|value| value}
+
+    # `[8]   string_annotation ::= STRING ":" STRING`
+    #
+    # Treated as an RDF annotation where the string is interpreted as a predicate based on the base_uri.
+    production(:string_annotation) do |value|
+      pred = base_uri.join("##{value.first[:STRING]}")
+      obj = value.last[:STRING]
+      PartialStatement.new(pred, obj)
+    end
+
+    # `[9]   rdf_annotation  ::= ((pn_local pname) | (IRI ":")) (STRING | IRI)`
+    #
+    # Returns a statement without subject
+    production(:rdf_annotation) do |value|
+      pred = value.first[:_rdf_annotation_1]
+      obj = value.last[:_rdf_annotation_2]
+      PartialStatement.new(pred, obj)
+    end
+    # `(seq pn_local pname)`
+    production(:_rdf_annotation_3) {|value| value.first[:pn_local].join(value.last[:pname])}
+    # `(seq IRI ":")`
+    production(:_rdf_annotation_4) {|value| value.first[:IRI]}
+
+    # `[10]  annotations_list  ::= "+" annotation ("," annotation)*`
+    production(:annotations_list) do |value|
+      value.last[:_annotations_list_1].unshift(value[1][:annotation])
+    end
+    # `(star _annotations_list_2)`
+    production(:_annotations_list_1) {|value| value.map {|al| al[1][:annotation]}}
+
+    # `[11]  props_list  ::= "[" prop ("," prop)* "]"`
+    production(:props_list) do |value|
+      value[2][:_props_list_1].unshift(value[1][:prop])
+    end
+    # `(star _props_list_2)`
+    production(:_props_list_1) {|value| value.map {|prop| prop[1][:prop]}}
+
+    # `[12]  graphs_list ::= "/" graph_name ("," graph_name)* "/"`
+    production(:graphs_list) do |value|
+      value[2][:_graphs_list_1].unshift(value[1][:graph_name])
+    end
+    # `seq "," graph_name)`
+    production(:_graphs_list_2) {|value| value.last[:graph_name]}
+
+    # `[13]  node  ::= "<" node_id ">" ("{" node_label ("," node_label)* "}")? props_list? graphs_list? annotations_list?
+    production(:node) do |value, data, callback|
+      subject = value[1][:node_id]
+      types = Array(value[3][:_node_1])
+      props = Array(value[4][:_node_2])
+      graphs = Array(value[5][:_node_3])
+      annotations = Array(value[6][:_node_4])
+
+      # Generate statements in named graphs, if present, otherwise, the default graph
+      graphs = [false] if graphs.empty?
+      graphs.each do |graph_name|
+        # Yield statements
+        types.each do |type|
+          callback.call(:statement, :node, subject, RDF.type, type, graph_name)
+        end
+        emit_statements(subject, props, graph_name) {|s, p, o, g| callback.call(:statement, :node, s, p, o, g)}
+        emit_statements(subject, annotations, graph_name) {|s, p, o, g| callback.call(:statement, :node, s, p, o, g)}
+      end
+
+      nil
+    end
+    # `(seq "{" node_label _node_6 "}")`
+    production(:_node_5) do |value|
+      value[2][:_node_6].unshift(value[1][:node_label])
+    end
+    # `(seq "," node_label)`
+    production(:_node_7) {|value| value.last[:node_label]}
+
+    # `[14]  edge  ::= directed | undirected`
+    #
+    # Ignores `edge_id` and `edge_label`. Treats `node_id` as a document-relative fragment.
+    production(:edge) do |value, data, callback|
+      value[:graphs].each do |graph_name|
+        # Statements in graphs, with inverse statement if :undirected
+        edges = [RDF::Statement(value[:subject], value[:predicate], value[:object])]
+        edges << RDF::Statement(value[:object], value[:predicate], value[:subject]) if value[:undirected]
+
+        edges.each do |edge|
+          # Emit each edge (per RDF*, edges don't have graph names)
+          callback.call(:statement, :edge, edge.subject, edge.predicate, edge.object)
+          emit_statements(edge, value[:props], graph_name) {|s, p, o, g| callback.call(:statement, :edge, s, p, o, g)}
+          emit_statements(edge, value[:annotations], graph_name) {|s, p, o, g| callback.call(:statement, :edge, s, p, o, g)}
+        end
+      end
+    end
+
+    # `[15]  section ::= "%" SECTION_NAME`
+    production(:section) do |value|
+      # Note the section we're parsing; this can generate a warning if parsing something outside the section (other than the next section), or if seeing past the last section
+      section = value.last[:SECTION_NAME].to_sym
+      if !@in_section.nil? && @in_section > SECTION_ORDERS[section.to_sym]
+        warn("section", "parsing section #{section} out of order.")
+      end
+      @in_section = SECTION_ORDERS[section.to_sym]
+      {section: section.to_sym}
+    end
+
+    # `[16]  directed  ::= "(" node_id ")" "-" ("<" edge_id ">")? "{" edge_label "}" props_list? "->" "(" node_id ")" graphs_list? annotations_list?`
+    production(:directed) do |value|
+      {
+        subject: value[1][:node_id],
+        predicate: value[6][:edge_label],
+        object: value[11][:node_id],
+        props: Array(value[8][:_directed_2]),
+        graphs: Array(value[13][:_directed_3] || false),
+        annotations: Array(value[14][ :_directed_4])
+      }
+    end
+
+    # `[17]  undirected  ::= "(" node_id ")" "-" ("<" edge_id ">")? "{" edge_label "}" props_list? "-" "(" node_id ")" graphs_list?` annotations_list?
+    production(:undirected) do |value|
+      {
+        subject: value[1][:node_id],
+        predicate: value[6][:edge_label],
+        object: value[11][:node_id],
+        props: Array(value[8][:_undirected_2]),
+        graphs: Array(value[13][:_undirected_3] || false),
+        annotations: Array(value[14][ :_undirected_4]),
+        undirected: true
+      }
+    end
+
+    # `[18]  node_id ::= STRING`
+    production(:node_id) {|value| base_uri.join("##{value.first[:STRING]}")}
+
+    # `[19]  node_label  ::= STRING`
+    production(:node_label) {|value| base_uri.join("##{value.first[:STRING]}")}
+
+    # `[20]  prop  ::= key ":" value
+    #
+    # Treated as an String annotation.
+    production(:prop) do |value|
+      pred = base_uri.join("##{value.first[:key]}")
+      obj = value.last[:value]
+      PartialStatement.new(pred, obj)
+    end
+
+    # Ignored
+    #production(:edge_id) {|value| value}
+    production(:edge_label) {|value| base_uri.join("##{value.first[:STRING]}")}
+    production(:key) {|value| value.first[:STRING].to_s}
+    #production(:value) {|value| value}
+
+    # `[25]  primitive_value ::= STRING | DATETYPE | NUMBER | BOOL | "null"`
+    production(:primitive_value) {|value| value == "null" ? RDF.nil : value}
+
+    # `[26]  complex_value ::= set | list | struct`
+    #
+    # At the start, record that we're from a complex value, so proper RDF values are created only after recursive calls are complete.
+    start_production(:complex_value) {|data| data[:from_complex_value] = true}
+    production(:complex_value) {|value| value}
+
+    # 27]  set ::= "{" (primitive_value | set) ("," (primitive_value | set))* "}"
+    #
+    # Because this is recursive, we'll only return a JSON literal if called from complex_value
+    production(:set) do |value|
+      set = value[2][:_set_2].unshift(value[1][:_set_1])
+      if prod_data[:from_complex_value]
+        # Wrap value in a literal
+        RDF::Literal(set.to_json_c14n, datatype: RDF.JSON)
+      else
+        set
+      end
+    end
+    # `(alt primitive_value struct)`
+    production(:_set_1) {|value| value.is_a?(RDF::Literal) ? value.to_s : value}
+    # `(seq "," _set_4)`
+    production(:_set_3) {|value| value.last[:_set_4]}
+    # `(alt primitive_value struct)`
+    production(:_set_4) {|value| value.is_a?(RDF::Literal) ? value.to_s : value}
+
+    # `[28]  list  ::= "[" (primitive_value | list) ("," (primitive_value | list))* "]"`
+    production(:list) do |value|
+      RDF::List(value[2][:_list_2].unshift(value[1][:_list_1]))
+    end
+    # (star _list_3)
+    production(:_list_2) do |value|
+      value.map {|li| li.last[:_list_4]}
+    end
+
+    # `[29]  struct  ::= "{" key ":" (primitive_value | struct) ("," key ":" (primitive_value | struct))* "}"`
+    #
+    # Because this is recursive, we'll only return a JSON literal if called from complex_value
+    production(:struct) do |value|
+      struct = {value[1][:key] => value[3][:_struct_1]}.merge(value[4][:_struct_2])
+      if prod_data[:from_complex_value]
+        # Wrap value in a literal
+        RDF::Literal(struct.to_json_c14n, datatype: RDF.JSON)
+      else
+        struct
+      end
+    end
+    # `(alt primitive_value struct)`
+    production(:_struct_1) {|value| value.is_a?(RDF::Literal) ? value.to_s : value}
+    # `(star _struct_3)`
+    production(:_struct_2) do |value|
+      value.inject({}) {|memo, struct| memo.merge(struct)}
+    end
+    # `(seq "," key ":" _struct_4)`
+    production(:_struct_3) {|value| {value[1][:key] => value[3][:_struct_4]}}
+    # `(alt primitive_value struct)`
+    production(:_struct_4) {|value| value.is_a?(RDF::Literal) ? value.to_s : value}
+
+    production(:node_schema) {|value| value}
+    production(:props_list_schema) {|value| value}
+    production(:prop_schema) {|value| value}
+    production(:value_schema) {|value| value}
+    production(:primitive_value_schema) {|value| value}
+    production(:complex_value_schema) {|value| value}
+    production(:set_schema) {|value| value}
+    production(:list_schema) {|value| value}
+    production(:struct_schema) {|value| value}
+    production(:edge_schema) {|value| value}
+    production(:directed_schema) {|value| value}
+    production(:undirected_schema) {|value| value}
+
+    ##
+    # Initializes a new reader instance.
+    #
+    # This assumes that strings are interpreted as document-relative fragments.
+    #
+    # @param  [String, #to_s]          input
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [Hash]     :prefixes     (Hash.new)
+    #   the prefix mappings to use (for acessing intermediate parser productions)
+    # @option options [#to_s]    :base_uri     (nil)
+    #   the base URI to use when resolving relative URIs (for acessing intermediate parser productions)
+    # @option options [Boolean]  :validate     (false)
+    #   whether to validate the parsed statements and values. If not validating,
+    #   the parser will attempt to recover from errors.
+    # @option options [Logger, #write, #<<] :logger
+    #   Record error/info/debug output
+    # @return [YARSPG::Reader]
+    def initialize(input = nil, **options, &block)
+      super do
+        @options[:base_uri] = RDF::URI(base_uri || "")
+        @options[:logger] = false unless @options.has_key?(:logger)
+        log_debug("base IRI") {base_uri.inspect}
+
+        if block_given?
+          case block.arity
+            when 0 then instance_eval(&block)
+            else block.call(self)
+          end
+        end
+      end
+    end
+
+    def inspect
+      sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, base_uri.to_s)
+    end
+
+    ##
+    # Iterates the given block for each RDF statement in the input.
+    #
+    # @yield  [statement]
+    # @yieldparam [RDF::Statement] statement
+    # @return [void]
+    def each_statement(&block)
+      if block_given?
+        log_recover
+        @callback = block
+
+        begin
+          parse(@input, :yarspg, YARSPG::Meta::RULES, **@options) do |context, *data|
+            case context
+            when :base_uri
+              @options[:base_uri] = data.first
+            when :statement
+              loc = data.shift
+              @callback.call(RDF::Statement.from(data))
+            end
+          end
+        rescue EBNF::PEG::Parser::Error
+          # Terminate loop if Errors found while parsing
+        end
+
+        if validate? && log_statistics[:error]
+          raise RDF::ReaderError, "Errors found during processing"
+        end
+      end
+      enum_for(:each_statement)
+    end
+    
+    ##
+    # Iterates the given block for each RDF triple in the input.
+    #
+    # @yield  [subject, predicate, object]
+    # @yieldparam [RDF::Resource] subject
+    # @yieldparam [RDF::URI]      predicate
+    # @yieldparam [RDF::Value]    object
+    # @return [void]
+    def each_triple(&block)
+      if block_given?
+        each_statement do |statement|
+          block.call(*statement.to_triple)
+        end
+      end
+      enum_for(:each_triple)
+    end
+
+    # Emit statements, accounting for lists
+    def emit_statements(subject, partials, graph_name)
+      partials.each do |partial|
+        if partial.object.list?
+          yield(subject, partial.predicate, partial.object.subject, graph_name)
+          partial.object.each_statement do |st|
+            yield(st.subject, st.predicate, st.object, graph_name)
+          end
+        else
+          yield(subject, partial.predicate, partial.object, graph_name)
+        end
+      end
+    end
+  end
+end

data/lib/yarspg/terminals.rb

@@ -0,0 +1,31 @@
+# coding: utf-8
+# Terminal definitions for EBNF Parser
+module YARSPG::Terminals
+  U_CHARS1         = Regexp.compile(<<-EOS.gsub(/\s+/, ''))
+                       [\\u00C0-\\u00D6]|[\\u00D8-\\u00F6]|[\\u00F8-\\u02FF]|
+                       [\\u0370-\\u037D]|[\\u037F-\\u1FFF]|[\\u200C-\\u200D]|
+                       [\\u2070-\\u218F]|[\\u2C00-\\u2FEF]|[\\u3001-\\uD7FF]|
+                       [\\uF900-\\uFDCF]|[\\uFDF0-\\uFFFD]|[\\u{10000}-\\u{EFFFF}]
+                     EOS
+  U_CHARS2         = Regexp.compile("\\u00B7|[\\u0300-\\u036F]|[\\u203F-\\u2040]", Regexp::FIXEDENCODING).freeze
+  IRI_RANGE        = Regexp.compile("[[^<>\"{}|^`\\\\]&&[^\\x00-\\x20]]", Regexp::FIXEDENCODING).freeze
+  UCHAR            = EBNF::LL1::Lexer::UCHAR
+
+  STRING_LITERAL_QUOTE = /"([^\"\\\n\r]|#{UCHAR})*"/.freeze
+  SIGN                 = %r([\+\-])u.freeze
+  PN_CHARS_BASE        = %r([A-Z]|[a-z]|[0-9]|#{U_CHARS1})u.freeze
+  PN_CHARS_U           = %r(_|(?:#{PN_CHARS_BASE}))u.freeze
+  PN_CHARS             = %r(-|[0-9]|(?:#{PN_CHARS_U})|#{U_CHARS2})u.freeze
+  STRING               = %r(#{STRING_LITERAL_QUOTE})u.freeze
+  NUMBER               = %r((?:#{SIGN})?\d+(\.\d*)?)u.freeze
+  BOOL                 = %r(true|false)u.freeze
+  ALNUM_PLUS           = %r((?:#{PN_CHARS_BASE})(?:(?:(?:#{PN_CHARS})|\.)*(?:#{PN_CHARS}))?)u.freeze
+  IRI                  = /<(?:(?:#{IRI_RANGE})|(?:#{UCHAR}))*>/u.freeze # prob with grammar
+  DATE                 = %r(\d\d\d\d-\d\d-\d\d)u.freeze
+  TIMEZONE             = %r((?:#{SIGN})?\d\d:\d\d)u.freeze
+  TIME                 = %r(\d\d:\d\d:\d\d(?:#{TIMEZONE})?)u.freeze
+  TIMESTAMP            = %r((?:#{DATE})T(?:#{TIME}))u.freeze
+  HEX                  = %r(\#x[0-9a-fA-F]+)u.freeze
+  COMMENT              = /(?:#[^\n\r\r]*)/u.freeze
+  WS                   = /(?:\s|(?:#{COMMENT}))+/m.freeze
+end

data/lib/yarspg/writer.rb

@@ -0,0 +1,10 @@
+module YARSPG
+  ##
+  # A YARS-PG serialiser
+  #
+  # @author [Gregg Kellogg](https://greggkellogg.net/)
+  class Writer < RDF::Writer
+    include RDF::Util::Logger
+    format YARSPG::Format
+  end
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: yarspg
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gregg Kellogg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: ebnf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: json-canonicalization
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: sxp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rdf-xsd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rdf-spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.20
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.20
+description: YARSPG is an YARS-PG reader/writer for the RDF.rb library suite.
+email: gregg@greggkellogg.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- UNLICENSE
+- VERSION
+- lib/yarspg.rb
+- lib/yarspg/format.rb
+- lib/yarspg/meta.rb
+- lib/yarspg/reader.rb
+- lib/yarspg/terminals.rb
+- lib/yarspg/version.rb
+- lib/yarspg/writer.rb
+homepage: https://github.com/gkellogg/yarspg
+licenses:
+- Unlicense
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.3
+signing_key: 
+specification_version: 4
+summary: YARS-PG reader/writer for RDF.rb.
+test_files: []