rdf-csv 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 99b5481fe4c21f0fedceb1fbd8660cb520415d6a
+  data.tar.gz: 606cbbeed5e25354ef019484e558667e9064235c
+SHA512:
+  metadata.gz: 694ce180441e8c15dc36c5ed59833ee0dc704d2e129a243858826f4e881b740b145ed9762cbd8565fa3f9d8beb8681146b663656f9a139a93daffe7ed2979623
+  data.tar.gz: 62556f047564cf65a11f58d2a394c8b24a589058258e9ac46447cea0e2d312422592e62d0e46fd830b97fe3db2b6aefe2b7ca577c6cd14335b75027f4610aa8b

data/AUTHORS

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

data/README.md

@@ -0,0 +1,77 @@
+# Tabular Data RDF Reader and JSON serializer
+
+[RDF-CSV][] reader for [RDF.rb][] and fully JSON serializer.
+
+[![Gem Version](https://badge.fury.io/rb/rdf-csv.png)](http://badge.fury.io/rb/rdf-csv)
+[![Build Status](https://secure.travis-ci.org/ruby-rdf/rdf-csv.png?branch=master)](http://travis-ci.org/ruby-rdf/rdf-csv)
+
+## Features
+
+RDF::CSV parses and serializes CSV or other Tabular Data into [RDF][] and JSON.
+
+Install with `gem install rdf-csv`
+
+## Examples
+
+    require 'rubygems'
+    require 'rdf/csv
+
+## RDF Reader
+{RDF::CSV} also acts as a normal RDF reader, using the standard RDF.rb Reader interface:
+
+    graph = RDF::Graph.load("etc/doap.csv")
+
+
+## Documentation
+Full documentation available on [RubyDoc](http://rubydoc.info/gems/rdf-csv/file/README.md)
+
+
+### Principal Classes
+* {RDF::CSV}
+  * {RDF::CSV::JSON}
+  * {RDF::CSV::Format}
+  * {RDF::CSV::Metadata}
+  * {RDF::CSV::Reader}
+
+## Dependencies
+* [Ruby](http://ruby-lang.org/) (>= 1.9.2)
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 1.0)
+* [JSON](https://rubygems.org/gems/json) (>= 1.5)
+
+## Installation
+The recommended installation method is via [RubyGems](http://rubygems.org/).
+To install the latest official release of the `RDF::CSV` gem, do:
+
+    % [sudo] gem install rdf-csv
+
+## Mailing List
+* <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
+
+## Author
+* [Gregg Kellogg](http://github.com/gkellogg) - <http://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.
+
+License
+-------
+
+This is free and unencumbered public domain software. For more information,
+see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
+
+[Ruby]:             http://ruby-lang.org/
+[RDF]:              http://www.w3.org/RDF/
+[YARD]:             http://yardoc.org/
+[YARD-GS]:          http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
+[PDD]:              http://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
+[RDF.rb]:           http://rubygems.org/gems/rdf

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 <http://unlicense.org/>

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/rdf/csv.rb

@@ -0,0 +1,17 @@
+$:.unshift(File.expand_path("..", __FILE__))
+require 'rdf' # @see http://rubygems.org/gems/rdf
+
+module RDF
+  ##
+  # **`RDF::CSV`** is a CSV extension for RDF.rb.
+  #
+  # @see http://w3c.github.io/csvw/
+  #
+  # @author [Gregg Kellogg](http://greggkellogg.net/)
+  module LD
+    require 'rdf/csv/format'
+    autoload :Reader,  'rdf/csv/reader'
+    autoload :VERSION, 'rdf/csv/version'
+    autoload :Writer,  'rdf/csv/writer'
+  end
+end

data/lib/rdf/csv/format.rb

@@ -0,0 +1,45 @@
+module RDF::CSV
+  ##
+  # Tabular Data/CSV format specification.
+  #
+  # @example Obtaining a CSV format class
+  #     RDF::Format.for(:csv)            #=> RDF::CSV::Format
+  #     RDF::Format.for(:tsv)            #=> RDF::CSV::Format
+  #     RDF::Format.for("etc/foaf.csv")
+  #     RDF::Format.for("etc/foaf.tsv")
+  #     RDF::Format.for(:file_name      => "etc/foaf.csv")
+  #     RDF::Format.for(:file_name      => "etc/foaf.tsv")
+  #     RDF::Format.for(:file_extension => "csv")
+  #     RDF::Format.for(:file_extension => "tsv")
+  #     RDF::Format.for(:content_type   => "text/csv")
+  #     RDF::Format.for(:content_type   => "text/tab-separated-values")
+  #
+  # @example Obtaining serialization format MIME types
+  #     RDF::Format.content_types      #=> {"text/csv" => [RDF::CSV::Format]}
+  #
+  # @example Obtaining serialization format file extension mappings
+  #     RDF::Format.file_extensions    #=> {:csv => "text/csv"}
+  #
+  # @see http://www.w3.org/TR/rdf-testcases/#ntriples
+  class Format < RDF::Format
+    content_type     'text/csv',
+                     extensions: [:csv, :tsv],
+                     alias: 'text/tab-separated-values'
+    content_encoding 'utf-8'
+
+    reader { RDF::CSV::Reader }
+
+    ##
+    # Sample detection to see if it matches JSON-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(/^(?:(?:\w )+,(?:\w ))$/)
+    end
+  end
+end

data/lib/rdf/csv/metadata.rb

@@ -0,0 +1,359 @@
+require 'json'
+require 'json/ld'
+require 'bcp47'
+
+##
+# CSVM Metadata processor
+#
+# * Extracts Metadata from file or Hash definition
+# * Merges multiple Metadata definitions
+# * Extract Metadata from a CSV file
+# * Return table-level annotations
+# * Return Column-level annotations
+# * Return row iterator with column information
+#
+# @author [Gregg Kellogg](http://greggkellogg.net/)
+module RDF::CSV
+  class Metadata < Hash
+    TABLE_GROUP_PROPERTIES = %(
+      resources schema table-direction dialect templates @type
+    ).map(&:to_sym).freeze
+    TABLE_GROUP_REQUIRED = [].freeze
+
+    TABLE_PROPERTIES = %(
+      @id schema notes table-direction templates dialect @type
+    ).map(&:to_sym).freeze
+    TABLE_REQUIRED = [:@id].freeze
+
+    DIALECT_DEFAULTS = {
+      commentPrefix:      nil,
+      delimiter:          ",".freeze,
+      doubleQuote:        true,
+      encoding:           "utf-8".freeze,
+      header:             true,
+      headerColumnnCount: 0,
+      headerRowCount:     1,
+      lineTerminator:     %r(\r?\n) # SPEC says "\r\n",
+      quoteChar:          '"',
+      skipBlankRows:      false,
+      skipColumns:        0,
+      skipInitialSpace:   false,
+      skipRows:           0,
+      trim:               false,
+      "@type" =>          nil
+    }.freeze
+
+    TEMPLATE_PROPERTIES = %(
+      targetFormat templateFormat title source @type
+    ).map(&:to_sym).freeze
+    TEMPLATE_REQUIRED = %(targetFormat templateFormat).map(&:to_sym).freeze
+
+    SCHEMA_PROPERTIES = %(
+      columns primaryKey foreignKeys uriTemplate @type
+    ).map(&:to_sym).freeze
+    SCHEMA_REQUIRED = [].freeze
+
+    COLUMN_PROPERTIES = %(
+      name title required @type
+    ).map(&:to_sym).freeze
+    COLUMN_REQUIRED = [:name].freeze
+
+    INHERITED_PROPERTIES = %w(
+      null language text-direction separator format datatype
+      length minLength maxLength minimum maximum
+      minInclusive maxInclusive minExclusive maxExclusive
+    ).map(&:to_sym).freeze
+
+    # Type of this Metadata
+    # @return [:TableGroup, :Table, :Template, :Schema, :Column]
+    attr_reader :type
+
+    # Parent of this Metadata (TableGroup for Table, ...)
+    # @return [Metadata]
+    attr_reader :parent
+
+    # Attempt to retrieve the file at the specified path. If it is valid metadata, create a new Metadata object from it, otherwise, an empty Metadata object
+    #
+    # @param [String] path
+    # @param [Hash{Symbol => Object}] options
+    #   see `RDF::Util::File.open_file` in RDF.rb
+    def self.open(path, options = {})
+      RDF::Util::File.open_file(path, options) {|file| Metadata.initialize(file, options)}
+    end
+
+    # Create Metadata from IO, Hash or String
+    #
+    # @param [Metadata, Hash, #read, #to_s] input
+    # @param [Hash{Symbol => Object}] options
+    # @option options [:TableGroup, :Table, :Template, :Schema, :Column] :type
+    #   Type of schema, if not set, intuited from properties
+    # @return [Metadata]
+    def initialize(input, options = {})
+      @options = options.dup
+
+      object = case
+      when input.is_a?(Metadata)      then return input
+      when input.respond_to?(:read)   then ::JSON.parse(input.read)
+      when input.is_a?(Hash)          then input
+      else                                 ::JSON.parse(input.to_s)
+      end
+
+      if options[:type]
+        @type = options[:type]
+        raise "If provided, type must be one of :TableGroup, :Table, :Template, :Schema, :Column]" unless
+          [:TableGroup, :Table, :Template, :Schema, :Column].include?(@type)
+      end
+
+      # Parent of this Metadata, if any
+      @parent = options[:parent]
+
+      # Metadata is object with symbolic keys
+      object.each do |key, value|
+        key = key.to_sym
+        case key
+        when :columns
+          # An array of template specifications that provide mechanisms to transform the tabular data into other formats
+          self[key] = if value.is_a?(Array) && value.all? {|v| v.is_a?(Hash)}
+            value.map {|v| Metadata.new(v, @options.merge(type: :Column, parent: self))}
+          else
+            # Invalid, but preserve value
+            value
+          end
+        when :dialect
+          # If provided, dialect provides hints to processors about how to parse the referenced file to create a tabular data model.
+          self[key] = case value
+          when Hash   then Metadata.new(value, @options.merge(type: :Dialect, parent: self))
+          else
+            # Invalid, but preserve value
+            value
+          end
+        when :resources
+          # An array of table descriptions for the tables in the group.
+          @type ||= :TableGroup
+          self[key] = if value.is_a?(Array) && value.all? {|v| v.is_a?(Hash)}
+            value.map {|v| Metadata.new(v, @options.merge(type: :Table, parent: self))}
+          else
+            # Invalid, but preserve value
+            value
+          end
+        when :schema
+          # An object property that provides a schema description as described in section 3.8 Schemas, for all the tables in the group. This may be provided as an embedded object within the JSON metadata or as a URL reference to a separate JSON schema document
+          self[key] = case value
+          when String then Metadata.open(value, @options.merge(type: :Schema, parent: self))
+          when Hash   then Metadata.new(value, @options.merge(type: :Schema, parent: self))
+          else
+            # Invalid, but preserve value
+            value
+          end
+        when :templates
+          # An array of template specifications that provide mechanisms to transform the tabular data into other formats
+          self[key] = if value.is_a?(Array) && value.all? {|v| v.is_a?(Hash)}
+            value.map {|v| Metadata.new(v, @options.merge(type: :Template, parent: self))}
+          else
+            # Invalid, but preserve value
+            value
+          end
+        when :targetFormat, :templateFormat, :source
+          @type ||= :Template
+          self[key] = value
+        when :primaryKey, :foreignKeys, :uriTemplate
+          @type ||= :Schema
+          self[key] = value
+        when :name, :required
+          @type ||= :Column
+          self[key] = value
+        when :@id
+          # URL of CSV relative to metadata
+          # XXX: base from @context, or location of last loaded metadata, or CSV itself. Need to keep track of file base when loading and merging
+          @location = @base.join(value)
+        else
+          self[key] = value
+        end
+      end
+
+      # Set type from @type, if present and not otherwise defined
+      @type ||= self[:@type] if self[:@type]
+    end
+
+    # Do we have valid metadata?
+    def valid?
+      validate!
+      true
+    rescue
+      false
+    end
+
+    # Raise error if metadata has any unexpected properties
+    def validate!
+      expected_props, required_props = case type
+      when :TableGroup then [TABLE_GROUP_PROPERTIES, TABLE_GROUP_REQUIRED]
+      when :Table      then [TABLE_PROPERTIES, TABLE_REQUIRED]
+      when :Dialect    then [DIALECT_DEFAULTS.keys, []]
+      when :Template   then [TEMPLATE_PROPERTIES, TEMPLATE_REQUIRED]
+      when :Schema     then [SCHEMA_PROPERTIES, SCHEMA_REQUIRED]
+      when :Column     then [COLUMN_PROPERTIES, COLUMN_REQUIRED]
+      else
+        raise "Unknown metadata type: #{type}"
+      end
+      expected_props = expected_props.merge(INHERITED_PROPERTIES)
+
+      # It has only expected properties
+      raise "#{type} has unexpected keys: #{keys}" unless keys.all? {|k| expected_proper.include?(k) || k.to_s.include?(':')}
+
+      # It has required properties
+      raise "#{type} missing required keys: #{keys}"  unless (required_props - keys) == required_props
+
+      # Every property is valid
+      each do |key, value|
+        is_valid = case key.to_s
+        when /:/  then true
+        when :columns then value.is_a?(Array) && value.all? {|v| v.is_a?(Metadata) && v.type == :Column && v.valid?}
+        when :commentPrefix then value.is_a?(String) && value.length == 1
+        when :datatype then value.is_a?(String) # FIXME validate against defined datatypes?
+        when :delimiter then value.is_a?(String) && value.length == 1
+        when :dialect then value.is_a?(Metadata) && v.type == :Dialect && value.valid?
+        when :doubleQuote then value == TrueClass || value == FalseClass
+        when :encoding then Encoding.find(value)
+        when :format then value.is_a?(String)
+        when :header then value == TrueClass || value == FalseClass
+        when :headerColumnCount then value.is_a?(String) && value.length == 1
+        when :headerRowCount then value.is_a?(String) && value.length == 1
+        when :length
+          value.is_a?(Number) && value.integer? && value >= 0 &&
+          self.fetch(:minLength, value) == value &&
+          self.fetch(:maxLength, value) == value
+        when :language then BCP47::Language.identify(value)
+        when :lineTerminator then value.is_a?(String)
+        when :minimum, :maximum, :minInclusive, :maxInclusive, :minExclusive, :maxExclusive
+          value.is_a?(Number) ||
+            RDF::Literal::Date.new(value).valid? ||
+            RDF::Literal::Time.new(value).valid? ||
+            RDF::Literal::DateTime.new(value).valid?
+        when :minLength, :maxLength
+          value.is_a?(Number) && value.integer? && value >= 0
+        when :name then value.is_a?(String)
+        when :notes then value.is_a?(Array) && value.all? {|v| v.is_a?(Hash)}
+        when :null then value.is_a?(String)
+        when :quoteChar then value.is_a?(String) && value.length == 1
+        when :required then value == TrueClass || value == FalseClass
+        when :resources then value.is_a?(Array) && value.all? {|v| v.is_a?(Metadata) && v.type == :Table && v.valid?}
+        when :schema then value.is_a?(Metadata) && value.type == :Schema && value.valid?
+        when :separator then value.is_a?(String) && value.length == 1
+        when :skipInitialSpace then value == TrueClass || value == FalseClass
+        when :skipBlankRows then value == TrueClass || value == FalseClass
+        when :skipColumns then value.is_a?(Number) && value.integer? && value >= 0
+        when :skipRows then value.is_a?(Number) && value.integer? && value >= 0
+        when :source then %w(json rdf).include?(value)
+        when :"table-direction" then %w(rtl ltr default).include?(value)
+        when :targetFormat, :templateFormat then RDF::URI(value).valid?
+        when :templates then value.is_a?(Array) && value.all? {|v| v.is_a?(Metadata) && v.type == :Template && v.valid?}
+        when :"text-direction" then %w(rtl ltr).include?(value)
+        when :title then valid_natural_language_property?(value)
+        when :trim then value == TrueClass || value == FalseClass || %w(true false start end).include?(value)
+        when :urlTemplate then value.is_a?(String)
+        when :"@id" then @location.valid?
+        when :"@type" then value.to_sym == type
+        when :primaryKey
+          # A column reference property that holds either a single reference to a column description object or an array of references.
+          Array(value).all? do |k|
+            self.columns.any? {|c| c.name == k}
+          end
+        when :foreignKey
+          # An array of foreign key definitions that define how the values from specified columns within this table link to rows within this table or other tables. A foreign key definition is a JSON object with the properties:
+          value.is_a?(Array) && value.all? do |fk|
+            raise "Foreign key must be an object" unless fk.is_a?(Hash)
+            columns, reference = fk['columns'], fk['reference']
+            raise "Foreign key missing columns and reference" unless columns && reference
+            raise "Foreign key has extra keys" unless fk.keys.length == 2
+            raise "Foreign key must reference columns" unless Array(columns).all? {|k| self.columns.any? {|c| c.name == k}}
+            raise "Foreign key resference must be an Object" unless reference.is-a?(Hash)
+
+            if reference.has_key?('resource')
+              raise "Foreign key having a resource reference, must not have a schema" if reference.has_key?('schema')
+              # FIXME resource is a URL of a specific resource (table) which must exist
+            elsif reference.has_key('schema')
+              # FIXME schema is a URL of a specific schema which must exist
+            end
+            # FIXME: columns
+          end
+        else
+          raise "?!?! shouldn't get here"
+        end
+
+        raise "#{type} has invalid #{key}: #{value.inspect}" unless is_valid
+      end
+    end
+
+    # Using Metadata, extract a new Metadata document from the file or data provided
+    #
+    # @param [#read, Array<String>, #to_s] table_data IO, or file path
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional options (see `RDF::Util::File.open_file`)
+    # @return [Metadata]
+    def file_metadata(table_data, options = {})
+      header_rows = []
+      CSV.new(table_data.respond_to?(:read) ? table_data : table_data.to_s) do |csv|
+        csv.shift for i in 0..skipRows.to_i # Skip initial lines
+        for i in 0..(headerRowCount || 1) do
+          csv.shift.each_with_index {|value, index| header_rows[index] << value}
+        end
+      end
+
+      # Join each header row value 
+    end
+
+    # Merge metadata into this a copy of this metadata
+    def merge(metadata)
+      self.dup.merge(Metadata.new(metadata))
+    end
+
+    # Merge metadata into self
+    def merge!(metadata)
+      other = Metadata.new(other)
+      # XXX ...
+    end
+
+    # Return Table-level metadata with inherited properties merged. If IO is
+    # provided, read CSV-level metadata from that file and merge
+    #
+    # @param [String, #to_s] id of Table if metadata is a TableGroup
+    # @param [#read, Hash, Array<Array<String>>] file IO, or Hash or Array of Arrays of column info
+    def table_data(id, file = nil)
+      table = if table_group?
+        data = table_group[id.to_s]
+        raise "No table with id #{id}" unless data
+        data = data.dup
+        inherited_properties.each do |p, v|
+          data.merge_property_value(p, v)
+        end
+        data
+      else
+        self.dup
+      end
+
+      if file
+        table.merge!(file_metadata(file)) 
+      else
+        table
+      end
+    end
+
+    # Return expanded annotation properties
+    # @return [Hash{String => Object}] FIXME
+    def expanded_annotation_properties
+    end
+
+    # Logic for accessing elements as accessors
+    def method_missing(method, *args)
+      if DIALECT_DEFAULTS.has_key?(method.to_sym)
+        # As set, or with default
+        self.fetch(method, DIALECT_DEFAULTS(method.to_sym))
+      elsif INHERITED_PROPERTIES.has_key?(method.to_sym)
+        # Inherited properties
+        self.fetch(method.to_sym, parent ? parent.send(method) : nil)
+      elsif method.to_sym == :name
+        # If not set, name comes from title
+        self.fetch(:name, self[:title])
+    end
+  end
+end

data/lib/rdf/csv/reader.rb

@@ -0,0 +1,148 @@
+require 'rdf'
+
+module RDF::CSV
+  ##
+  # A Tabular Data to RDF parser in Ruby.
+  #
+  # @author [Gregg Kellogg](http://greggkellogg.net/)
+  class Reader < RDF::Reader
+    format Format
+
+    # Metadata associated with the CSV
+    #
+    # @return [Metadata]
+    attr_reader :metadata
+
+    ##
+    # Open a CSV file or URI. Also attempts to load relevant metadata
+    #
+    # @param  [String, #to_s] filename
+    # @param  [Hash{Symbol => Object}] options
+    #   see `RDF::Util::File.open_file` in RDF.rb
+    # @yield  [reader]
+    # @yieldparam  [RDF::CSV::Reader] reader
+    # @yieldreturn [void] ignored
+    def self.open(filename, options = {}, &block)
+      Util::File.open_file(filename, options) do |file|
+        # load link metadata, if available
+        metadata = if file.respond_to?(:links)
+          link = file.links.find_link(%w(rel describedby))
+          Metadata.open(link, options)
+        end
+
+        # Otherwise, look for metadata based on filename
+        metadata ||= Metadata.open("#{filename}-metadata.json", options)
+
+        # Otherwise, look for metadata in directory
+        metadata ||= Metadata.open(RDF::URI(filename).join("metadata.json"), options)
+
+        if metadata
+          # Merge options
+          metadata.merge!(options[:metadata]) if options[:metadata]
+        else
+          # Just use options
+          metadata = options[:metadata]
+        end
+
+        # Return an open CSV with possible block
+        RDF::CSV::Reader.new(file, options.merge(metadata: metadata), &block)
+      end
+    end
+
+    ##
+    # Initializes the RDF::CSV Reader instance.
+    #
+    # @param  [IO, File, String]       input
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional options (see `RDF::Reader#initialize`)
+    # @option options [Metadata, Hash] :metadata extracted when file opened
+    # @option options [Metadata, Hash] :user_metadata user supplied metadata, merged on top of extracted metadata
+    # @yield  [reader] `self`
+    # @yieldparam  [RDF::Reader] reader
+    # @yieldreturn [void] ignored
+    # @raise [RDF::ReaderError] if the CSV document cannot be loaded
+    def initialize(input = $stdin, options = {}, &block)
+      options[:base_uri] ||= options[:base]
+      super do
+        @options[:base] ||= base_uri.to_s if base_uri
+        # Construct metadata from that passed from file open, along with information from the file.
+        @metadata = Metadata.new(options[:metadata]).table_data(base_uri, input)
+
+        # Merge any user-supplied metadata
+        # SPEC CONFUSION: Note issue described in https://github.com/w3c/csvw/issues/76#issuecomment-65914880
+        @metadata.merge(Metadata.new(options[:user_metadata])) if options[:user_metadata]
+        @doc = input.respond_to?(:read) ? input : StringIO.new(input.to_s)
+
+        if block_given?
+          case block.arity
+            when 0 then instance_eval(&block)
+            else block.call(self)
+          end
+        end
+      end
+    end
+
+    ##
+    # @private
+    # @see   RDF::Reader#each_statement
+    def each_statement(&block)
+      if block_given?
+        @callback = block
+
+        # Output Table-Level RDF triples
+        # SPEC FIXME: csvw:Table, not csv:Table
+        add_triple(0, RDF::URI(metadata.id), RDF.type, CSVW.Table) if metadata.type?
+
+        # Output other table-level metadata
+        # SPEC AMBIGUITY(2RDF):
+        #   output all optional properties in DC space? (they're typically defined in CSVM space)
+        #   output all namespaced properties?
+        #   output all non-namespaced properties which aren't specifically defined in CSVM in DC space?
+        # We assume to only output namesspaced-properties
+        metadata.expanded_annotation_properties.each do |prop, values|
+          Array(value).each do |v|
+            # Assume prop and value(s) are in RDF form? or expand here?
+            add_triple(0, metadata.uri, RDF::URI(prop), v)
+          end
+        end
+
+        # SPEC CONFUSION(2RDF):
+        #   Where to output column-level, vs. cell-level metadata?
+        metadata.columns.each do |column|
+          # SPEC FIXME: Output csvw:Column, if set
+          add_triple(0, RDF::URI(column.uri), RDF.type, CSVW.Column) if column.type?
+          column.expanded_annotation_properties.each do |prop, values|
+            Array(value).each do |v|
+              # Assume prop and value(s) are in RDF form? or expand here?
+              add_triple(0, RDF::URI(column.uri), RDF::URI(prop), v)
+            end
+          end
+        end
+
+        # Output Cell-Level RDF triples
+        metadata.rows.each do |row|
+          # Output row-level metadata
+          add_triple(row.rownum, RDF::URI(row.uri), CSVW.row, RDF::Literal::Integer(row.rownum))
+          add_triple(row.rownum, RDF::URI(row.uri), RDF.type, CSVW.Row) if row.type?
+          row.columns.each_with_index do |column|
+            add_triple("#{row.rownum}", RDF::URI(row.uri), RDF::URI(column.uri), column.rdf_value)
+          end
+        end
+      end
+      enum_for(:each_statement)
+    end
+
+    ##
+    # @private
+    # @see   RDF::Reader#each_triple
+    def each_triple(&block)
+      if block_given?
+        each_statement do |statement|
+          block.call(*statement.to_triple)
+        end
+      end
+      enum_for(:each_triple)
+    end
+  end
+end
+

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: rdf-csv
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Gregg Kellogg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.7
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rdf-spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rdf-turtle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rdf-isomorphic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  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: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: RDF::CSV processes tabular data with metadata creating RDF or JSON output.
+email: public-rdf-ruby@w3.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- AUTHORS
+- README.md
+- UNLICENSE
+- VERSION
+- lib/rdf/csv.rb
+- lib/rdf/csv/format.rb
+- lib/rdf/csv/json.rb
+- lib/rdf/csv/metadata.rb
+- lib/rdf/csv/reader.rb
+homepage: http://github.com/ruby-rdf/rdf-csv
+licenses:
+- Public Domain
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Tabular Data RDF Reader and JSON serializer.
+test_files: []
+has_rdoc: false