rdf 1.99.1 → 2.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d489709cc4b64608bfb4a353a63d918f012732ff
-  data.tar.gz: f9efffc401e1ba7cc000fe3fc737608487e0d7c1
+  metadata.gz: d6b5ce1d8969fb6463efd82a7fe9826589bac799
+  data.tar.gz: e0c0066693ddc81d5089bf63f7502527750d1380
 SHA512:
-  metadata.gz: 4eeabcffc5ccdb6db0d0ff2d79bf1e25dae0d4d33e07d4a561e970497430991ae70a6e8a56450b746c69e0a26f68c930e244f7e4416d5647cd25dd69cb2e159c
-  data.tar.gz: 2c9d36a52c4e56bc7032aaf2a584bb90ee131dc36256f2cf10af2698affdb70d8e21ab6e70969fff021b3d7a11bca67e235525831fcadeb59dd150e3aebeb57d
+  metadata.gz: f866ac2a48e98e154bd786f6e0c30f5298e70c01de47847c660fded022f14ef58f19b0a727e20a53704d0d46f610cae4f53a08b5b2b94dc5f82d85da006e9d0b
+  data.tar.gz: ccede9fff108419d7d0df702df4dd8e8a24bd53be1e0aa0bd1a1986158ff5dcdbfd7bb824eb36cbe1dc0ea41243732bb49f0aec5dbbf869721595911e7f39709

data/{README → README.md}

@@ -11,6 +11,8 @@ This is a pure-Ruby library for working with [Resource Description Framework
 
 [![Gem Version](https://badge.fury.io/rb/rdf.png)](http://badge.fury.io/rb/rdf)
 [![Build Status](https://travis-ci.org/ruby-rdf/rdf.png?branch=master)](http://travis-ci.org/ruby-rdf/rdf)
+[![Code Climate](https://codeclimate.com/github/ruby-rdf/rdf/badges/gpa.svg)](https://codeclimate.com/github/ruby-rdf/rdf)
+[![Coverage Status](https://coveralls.io/repos/ruby-rdf/rdf/badge.svg)](https://coveralls.io/r/ruby-rdf/rdf)
 [![Join the chat at https://gitter.im/ruby-rdf/rdf](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/ruby-rdf/rdf?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 ## Features
@@ -28,8 +30,7 @@ This is a pure-Ruby library for working with [Resource Description Framework
   not modify any of Ruby's core classes or standard library.
 * Based entirely on Ruby's autoloading, meaning that you can generally make
   use of any one part of the library without needing to load up the rest.
-* Compatible with Ruby Ruby 1.9.2, Ruby 2.0, Rubinius and JRuby 1.7+.
-* Compatible with older Ruby versions with the help of the [Backports][] gem.
+* Compatible with Ruby Ruby 2.x, Rubinius and JRuby 1.7+ (in Ruby 2.0 mode).
 * Performs auto-detection of input to select appropriate Reader class if one
   cannot be determined from file characteristics.
 
@@ -50,12 +51,12 @@ the 1.1 release of RDF.rb:
 * Introduces {RDF::IRI}, as a synonym for {RDF::URI} either {RDF::IRI} or {RDF::URI} can be used interchangeably. Versions of RDF.rb prior to the 1.1 release were already compatible with IRIs. Internationalized Resource Identifiers (see [RFC3987][]) are a super-set of URIs (see [RFC3986][]) which allow for characters other than standard US-ASCII.
 * {RDF::URI} no longer uses the `Addressable` gem. As URIs typically don't need to be parsed, this provides a substantial performance improvement when enumerating or querying graphs and repositories.
 * {RDF::List} no longer emits a `rdf:List` type. However, it will now recognize any subjects that are {RDF::Node} instances as being list elements, as long as they have both `rdf:first` and `rdf:rest` predicates.
-* {RDF::Graph} adding a `context` to a graph may only be done when the underlying storage model supports contexts (the default {RDF::Repository} does). The notion of `context` in RDF.rb is treated equivalently to [Named Graphs](http://www.w3.org/TR/rdf11-concepts/#dfn-named-graph) within an RDF Dataset, and graphs on their own are not named.
+* {RDF::Graph} adding a `graph_name` to a graph may only be done when the underlying storage model supports graph_names (the default {RDF::Repository} does). The notion of `graph_name` in RDF.rb is treated equivalently to [Named Graphs](http://www.w3.org/TR/rdf11-concepts/#dfn-named-graph) within an RDF Dataset, and graphs on their own are not named.
 * {RDF::Graph}, {RDF::Statement} and {RDF::List} now include {RDF::Value}, and not {RDF::Resource}. Made it clear that using {RDF::Graph} does not mean that it may be used within an {RDF::Statement}, for this see {RDF::Term}.
 * {RDF::Statement} now is stricter about checking that all elements are valid when validating.
 * {RDF::NTriples::Writer} and {RDF::NQuads::Writer} now default to validate output, only allowing valid statements to be emitted. This may disabled by setting the `:validate` option to `false`.
 * {RDF::Dataset} is introduced as a class alias of {RDF::Repository}. This allows closer alignment to the RDF concept of [Dataset](http://www.w3.org/TR/rdf11-concepts/#dfn-dataset).
-* The `context` (or `name`) of a named graph within a Dataset or Repository may be either an {RDF::IRI} or {RDF::Node}. Implementations of repositories may restrict this to being only {RDF::IRI}.
+* The `graph_name` of a graph within a Dataset or Repository may be either an {RDF::IRI} or {RDF::Node}. Implementations of repositories may restrict this to being only {RDF::IRI}.
 * There are substantial and somewhat incompatible changes to {RDF::Literal}. In [RDF 1.1][], all literals are typed, including plain literals and language tagged literals. Internally, plain literals are given the `xsd:string` datatype and language tagged literals are given the `rdf:langString` datatype. Creating a plain literal, without a datatype or language, will automatically provide the `xsd:string` datatype; similar for language tagged literals. Note that most serialization formats will remove this datatype. Code which depends on a literal having the `xsd:string` datatype being different from a plain literal (formally, without a datatype) may break. However note that the `#has\_datatype?` will continue to return `false` for plain or language-tagged literals.
 * {RDF::Query#execute} now accepts a block and returns {RDF::Query::Solutions}. This allows `enumerable.query(query)` to behave like `query.execute(enumerable)` and either return an enumerable or yield each solution.
 * {RDF::Queryable#query} now returns {RDF::Query::Solutions} instead of an Enumerator if it's argument is an {RDF::Query}.
@@ -146,7 +147,7 @@ appropriate writer to use.
 
     RDF::Writer.open("hello.nq", format: :nquads) do |writer|
       writer << RDF::Repository.new do |repo|
-        repo << RDF::Statement.new(:hello, RDF::RDFS.label, "Hello, world!", context: RDF::URI("context"))
+        repo << RDF::Statement.new(:hello, RDF::RDFS.label, "Hello, world!", graph_name: RDF::URI("http://example/graph_name"))
       end
     end
 
@@ -154,7 +155,7 @@ A specific sub-type of Writer can also be invoked directly:
 
     require 'rdf/nquads'
 
-    repo = RDF::Repository.new << RDF::Statement.new(:hello, RDF::RDFS.label, "Hello, world!", context: RDF::URI("context"))
+    repo = RDF::Repository.new << RDF::Statement.new(:hello, RDF::RDFS.label, "Hello, world!", graph_name: RDF::URI("http://example/graph_name"))
     File.open("hello.nq", "w") {|f| f << repo.dump(:nquads)}
 
 ## Reader/Writer convenience methods
@@ -298,7 +299,6 @@ from BNode identity (i.e., they each entail the other)
   * {RDF::Countable}
   * {RDF::Enumerable}
   * {RDF::Indexable}
-  * {RDF::Inferable}
   * {RDF::Queryable}
   * {RDF::Mutable}
   * {RDF::Durable}
@@ -327,44 +327,10 @@ from BNode identity (i.e., they each entail the other)
 * {RDF::RDFV}   - RDF Vocabulary (RDFV)
 * {RDF::XSD}    - XML Schema (XSD)
 
-#### Deprecated Vocabularies
-
-The following vocabularies will be deprecated in RDF.rb 2.0 and moved to the rdf-vocab gem.
-
-* {RDF::CC}     - Creative Commons (CC)
-* {RDF::CERT}   - W3 Authentication Certificate (CERT)
-* {RDF::DC}     - Dublin Core (DC)
-* {RDF::DC11}   - Dublin Core 1.1 (DC11) _deprecated_
-* {RDF::DOAP}   - Description of a Project (DOAP)
-* {RDF::EXIF}   - Exchangeable Image File Format (EXIF)
-* {RDF::FOAF}   - Friend of a Friend (FOAF)
-* {RDF::GEO}    - WGS84 Geo Positioning (GEO)
-* {RDF::GR}     - GoodRelations (GR)
-* {RDF::HT}     - Hypertext Transfer Protocol (HT)
-* {RDF::ICAL}   - RDF Calendar Workspace (ICAL)
-* {RDF::MA}     - Media Resources (MA)
-* {RDF::MO}     - Music Ontology (MO)
-* {RDF::OG}     - Open Graph protocol (OG)
-* {RDF::PROV}   - Provenance on the web (PROV)
-* {RDF::RSA}    - W3 RSA Keys (RSA)
-* {RDF::RSS}    - RDF Site Summary (RSS)
-* {RDF::SCHEMA} - Schema.org (SCHEMA)
-* {RDF::SIOC}   - Semantically-Interlinked Online Communities (SIOC)
-* {RDF::SKOS}   - Simple Knowledge Organization System (SKOS)
-* {RDF::SKOSXL} - SKOS eXtension for Labels (SKOSXL)
-* {RDF::V}      - RDF data vocabulary (V)
-* {RDF::VCARD}  - Ontology for vCards (VCARD)
-* {RDF::VMD}    - Data-Vocabulary.org (VMD)
-* {RDF::VOID}   - Vocabulary of Interlinked Datasets (VOID)
-* {RDF::VS}     - SemWeb Vocab Status ontology (VS)
-* {RDF::WDRS}   - Protocol for Web Description Resources (WDRS)
-* {RDF::WOT}    - Web of Trust (WOT)
-* {RDF::XHTML}  - Extensible HyperText Markup Language (XHTML)
-* {RDF::XHV}    - XHTML Vocabulary (XHV)
 
 ## Dependencies
 
-* [Ruby](http://ruby-lang.org/) (>= 1.9.2)
+* [Ruby](http://ruby-lang.org/) (>= 2.0)
 * [LinkHeader][] (>= 0.0.8)
 * Soft dependency on [RestClient][] (>= 1.7)
 
@@ -373,7 +339,7 @@ The following vocabularies will be deprecated in RDF.rb 2.0 and moved to the rdf
 The recommended installation method is via [RubyGems](http://rubygems.org/).
 To install the latest official release of RDF.rb, do:
 
-    % [sudo] gem install rdf             # Ruby 1.9.2+
+    % [sudo] gem install rdf             # Ruby 2+
 
 ## Download
 
@@ -452,7 +418,6 @@ see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [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
-[Backports]:        http://rubygems.org/gems/backports
 [JSONLD doc]:       http://rubydoc.info/github/ruby-rdf/json-ld/frames
 [LinkedData doc]:   http://rubydoc.info/github/datagraph/linkeddata/master/frames
 [Microdata doc]:    http://rubydoc.info/github/ruby-rdf/rdf-microdata/frames

data/VERSION

@@ -1 +1 @@
-1.99.1
+2.0.0.beta1

data/bin/rdf

@@ -5,7 +5,7 @@ require 'rdf/cli'
 
 options = RDF::CLI.options do
   self.on('-v', '--verbose', 'Enable verbose output. May be given more than once.') do
-    $VERBOSE = true
+    self.options[:logger].level = Logger::INFO
   end
 
   self.on('-V', '--version', 'Display the RDF.rb version and exit.') do

data/lib/rdf.rb

@@ -7,72 +7,61 @@ require 'rdf/version'
 
 module RDF
   # RDF mixins
-  autoload :Countable,   'rdf/mixin/countable'
-  autoload :Durable,     'rdf/mixin/durable'
-  autoload :Enumerable,  'rdf/mixin/enumerable'
-  autoload :Indexable,   'rdf/mixin/indexable'
-  autoload :Inferable,   'rdf/mixin/inferable'
-  autoload :Mutable,     'rdf/mixin/mutable'
-  autoload :Queryable,   'rdf/mixin/queryable'
-  autoload :Readable,    'rdf/mixin/readable'
-  autoload :TypeCheck,   'rdf/mixin/type_check'
-  autoload :Writable,    'rdf/mixin/writable'
+  autoload :Countable,         'rdf/mixin/countable'
+  autoload :Durable,           'rdf/mixin/durable'
+  autoload :Enumerable,        'rdf/mixin/enumerable'
+  autoload :Indexable,         'rdf/mixin/indexable'
+  autoload :Mutable,           'rdf/mixin/mutable'
+  autoload :Queryable,         'rdf/mixin/queryable'
+  autoload :Readable,          'rdf/mixin/readable'
+  autoload :TypeCheck,         'rdf/mixin/type_check'
+  autoload :Transactable,      'rdf/mixin/transactable'
+  autoload :Writable,          'rdf/mixin/writable'
 
   # RDF objects
-  autoload :Graph,       'rdf/model/graph'
-  autoload :IRI,         'rdf/model/uri'
-  autoload :Literal,     'rdf/model/literal'
-  autoload :Node,        'rdf/model/node'
-  autoload :Resource,    'rdf/model/resource'
-  autoload :Statement,   'rdf/model/statement'
-  autoload :URI,         'rdf/model/uri'
-  autoload :Value,       'rdf/model/value'
-  autoload :Term,        'rdf/model/term'
+  autoload :Graph,             'rdf/model/graph'
+  autoload :IRI,               'rdf/model/uri'
+  autoload :Literal,           'rdf/model/literal'
+  autoload :Node,              'rdf/model/node'
+  autoload :Resource,          'rdf/model/resource'
+  autoload :Statement,         'rdf/model/statement'
+  autoload :URI,               'rdf/model/uri'
+  autoload :Value,             'rdf/model/value'
+  autoload :Term,              'rdf/model/term'
 
   # RDF collections
-  autoload :List,        'rdf/model/list'
+  autoload :List,              'rdf/model/list'
 
   # RDF serialization
-  autoload :Format,      'rdf/format'
-  autoload :Reader,      'rdf/reader'
-  autoload :ReaderError, 'rdf/reader'
-  autoload :Writer,      'rdf/writer'
-  autoload :WriterError, 'rdf/writer'
+  autoload :Format,            'rdf/format'
+  autoload :Reader,            'rdf/reader'
+  autoload :ReaderError,       'rdf/reader'
+  autoload :Writer,            'rdf/writer'
+  autoload :WriterError,       'rdf/writer'
 
   # RDF serialization formats
-  autoload :NTriples,    'rdf/ntriples'
-  autoload :NQuads,      'rdf/nquads'
+  autoload :NTriples,          'rdf/ntriples'
+  autoload :NQuads,            'rdf/nquads'
 
   # RDF storage
-  autoload :Dataset,     'rdf/model/repository'
-  autoload :Repository,  'rdf/repository'
-  autoload :Transaction, 'rdf/transaction'
+  autoload :Changeset,         'rdf/changeset'
+  autoload :Dataset,           'rdf/model/dataset'
+  autoload :Repository,        'rdf/repository'
+  autoload :Transaction,       'rdf/transaction'
 
   # RDF querying
-  autoload :Query,       'rdf/query'
+  autoload :Query,             'rdf/query'
 
   # RDF vocabularies
-  autoload :Vocabulary,  'rdf/vocabulary'
+  autoload :Vocabulary,        'rdf/vocabulary'
   autoload :StrictVocabulary,  'rdf/vocabulary'
   VOCABS = Dir.glob(File.join(File.dirname(__FILE__), 'rdf', 'vocab', '*.rb')).map { |f| File.basename(f)[0...-(File.extname(f).size)].to_sym } rescue []
 
-  # Ruby versions < 2.0 are deprecated in RDF.rb 2.0
-  warn %([DEPRECATION] Ruby versions before 2.0 are no longer supported starting with RDF.rb 2.0.) if RUBY_VERSION < "2.0"
-
   # Use const_missing instead of autoload to load most vocabularies so we can provide deprecation messages
   def self.const_missing(constant)
     if VOCABS.include?(constant.to_s.downcase.to_sym)
-      @vocab_fault ||= {}
-      raise "Class not found: RDF::#{constant}" if @vocab_fault[constant.to_s]
-      @vocab_fault[constant.to_s] = true
-      warn %([DEPRECATION] the #{constant} vocabulary will be moved to the rdf-vocab gem
-        for the RDF.rb 2.0 release. Use as RDF::Vocab::#{constant}, or include RDF::Vocab in the RDF module.
-        Called from #{Gem.location_of_caller.join(':')}
-      ).gsub(/^\s+/, '') unless [:OWL, :RDFS, :RDFV, :XSD].include?(constant)
       require "rdf/vocab/#{constant.to_s.downcase}"
-      klass = const_get(constant)
-      return klass if klass
-      raise "Class not found: RDF::#{constant}"
+      const_get(constant)
     else
       super
     end
@@ -131,8 +120,12 @@ module RDF
   #
   # @param (see RDF::Graph#initialize)
   # @return [RDF::Graph]
-  def self.Graph(*args, &block)
-    Graph.new(*args, &block)
+  def self.Graph(*args, **options, &block)
+    unless args.empty?
+      warn "[DEPRECATION] Graph#initialize now uses keyword arguments. Called from #{Gem.location_of_caller.join(':')}"
+      options[:graph_name] ||= args.first
+    end
+    Graph.new(options, &block)
   end
 
   ##
@@ -172,8 +165,6 @@ module RDF
   #   @option options [RDF::Resource]  :subject   (nil)
   #   @option options [RDF::URI]       :predicate (nil)
   #   @option options [RDF::Term]      :object    (nil)
-  #   @option options [RDF::Resource]  :context   (nil)
-  #     Alias for :graph_name, :context is deprecated in RDF.rb.
   #   @option options [RDF::Resource]  :graph_name   (nil)
   #     Note, a graph_name MUST be an IRI or BNode.
   #   @return [RDF::Statement]

data/lib/rdf/changeset.rb

@@ -0,0 +1,161 @@
+module RDF
+  ##
+  # An RDF changeset that can be applied to an {RDF::Mutable}.
+  #
+  # Changesets consist of a sequence of RDF statements to delete from and a
+  # sequence of RDF statements to insert into a target dataset. 
+  # 
+  # @example Applying a Changeset with block syntax
+  #   graph = RDF::Graph.new
+  #   graph << [RDF::URI('s_del'), RDF::URI('p_del'), RDF::URI('o_del')]
+  #
+  #   RDF::Changeset.apply(graph) do |c|
+  #     c.insert [RDF::URI('s1'), RDF::URI('p1'), RDF::URI('o1')]
+  #     c.insert [RDF::URI('s2'), RDF::URI('p2'), RDF::URI('o2')]
+  #     c.delete [RDF::URI('s_del'), RDF::URI('p_del'), RDF::URI('o_del')]
+  #   end
+  #
+  # @example Defining a changeset for later application to a Mutable
+  #   changes = RDF::Changeset.new do |c|
+  #     c.insert [RDF::URI('s1'), RDF::URI('p1'), RDF::URI('o1')]
+  #     c.insert [RDF::URI('s2'), RDF::URI('p2'), RDF::URI('o2')]
+  #     c.delete [RDF::URI('s_del'), RDF::URI('p_del'), RDF::URI('o_del')]
+  #   end
+  #
+  #   graph = RDF::Graph.new
+  #   graph << [RDF::URI('s_del'), RDF::URI('p_del'), RDF::URI('o_del')]
+  # 
+  #   changes.apply(graph) # or graph.apply_changeset(changes)
+  #
+  # @note When applying a Changeset, deletes are resolved before inserts.
+  #
+  # @since 2.0.0
+  class Changeset
+    include RDF::Mutable
+
+    ##
+    # Applies a changeset to the given mutable RDF::Enumerable .
+    #
+    # @param  [RDF::Mutable] mutable
+    # @param  [Hash{Symbol => Object}] options
+    # @yield  [changes]
+    # @yieldparam [RDF::Changeset] changes
+    # @return [void]
+    def self.apply(mutable, options = {}, &block)
+      self.new(&block).apply(mutable, options)
+    end
+
+    ##
+    # RDF statements to delete when applied.
+    #
+    # @return [RDF::Enumerable]
+    attr_reader :deletes
+
+    ##
+    # RDF statements to insert when applied.
+    #
+    # @return [RDF::Enumerable]
+    attr_reader :inserts
+
+    ##
+    # Any additional options for this changeset.
+    #
+    # @return [Hash{Symbol => Object}]
+    attr_reader :options
+
+    ##
+    # Initializes this changeset.
+    #
+    # @param [RDF::Enumerable] insert (RDF::Graph.new)
+    # @param [RDF::Enumerable] delete (RDF::Graph.new)
+    # @yield  [changes]
+    # @yieldparam [RDF::Changeset] changes
+    def initialize(insert: [], delete: [], &block)
+      @inserts = insert
+      @deletes = delete
+
+      @inserts.extend(RDF::Enumerable) unless @inserts.kind_of?(RDF::Enumerable)
+      @deletes.extend(RDF::Enumerable) unless @deletes.kind_of?(RDF::Enumerable)
+
+      if block_given?
+        case block.arity
+          when 1 then block.call(self)
+          else self.instance_eval(&block)
+        end
+      end
+    end
+
+    ##
+    # Returns `false` to indicate that this changeset is append-only.
+    #
+    # Changesets do not support the `RDF::Enumerable` protocol directly.
+    # To enumerate the RDF statements to be inserted or deleted, use the
+    # {RDF::Changeset#inserts} and {RDF::Changeset#deletes} accessors.
+    #
+    # @return [Boolean]
+    # @see    RDF::Readable#readable?
+    def readable?
+      false
+    end
+
+    ##
+    # Applies this changeset to the given mutable RDF::Enumerable.
+    #
+    # This operation executes as a single write transaction.
+    #
+    # @param  [RDF::Mutable] mutable
+    # @param  [Hash{Symbol => Object}] options
+    # @return [void]
+    def apply(mutable, options = {})
+      mutable.apply_changeset(self)
+    end
+
+    ##
+    # @return [Boolean] `true` iff inserts and deletes are both empty
+    def empty?
+      deletes.empty? && inserts.empty?
+    end
+
+    ##
+    # Returns a developer-friendly representation of this changeset.
+    #
+    # @return [String]
+    def inspect
+      sprintf("#<%s:%#0x(deletes: %d, inserts: %d)>", self.class.name,
+        self.__id__, self.deletes.count, self.inserts.count)
+    end
+
+    ##
+    # Outputs a developer-friendly representation of this changeset to
+    # `stderr`.
+    #
+    # @return [void]
+    def inspect!
+      $stderr.puts(self.inspect)
+    end
+
+    protected
+
+    ##
+    # Appends an RDF statement to the sequence to insert when applied.
+    #
+    # @param  [RDF::Statement] statement
+    # @return [void]
+    # @see    RDF::Writable#insert_statement
+    def insert_statement(statement)
+      self.inserts << statement
+    end
+
+    ##
+    # Appends an RDF statement to the sequence to delete when applied.
+    #
+    # @param  [RDF::Statement] statement
+    # @return [void]
+    # @see    RDF::Mutable#delete_statement
+    def delete_statement(statement)
+      self.deletes << statement
+    end
+
+    undef_method :load, :update, :clear
+  end # Changeset
+end # RDF

data/lib/rdf/cli.rb

@@ -1,6 +1,7 @@
 require 'rdf'
 require 'rdf/ntriples'
 require 'rdf/nquads'
+require 'logger'
 require 'optparse'
 begin
   gem 'linkeddata'
@@ -13,6 +14,11 @@ rescue LoadError
     rescue LoadError
     end
   end
+
+  begin
+    require 'json/ld'
+  rescue LoadError
+  end
 end
 
 class OptionParser
@@ -21,10 +27,87 @@ class OptionParser
 end
 
 module RDF
+  # Individual formats can modify options by updating {Reader.options} or {Writer.options}. Format-specific commands are taken from {Format.cli_commands} for each loaded format, which returns an array of lambdas taking arguments and options.
+  #
+  # @example Creating Reader-specific options:
+  #   class Reader
+  #     def self.options
+  #       [
+  #         RDF::CLI::Option.new(
+  #           symbol: :canonicalize,
+  #           datatype: TrueClass,
+  #           on: ["--canonicalize"],
+  #           description: "Canonicalize input/output.") {true},
+  #         ...
+  #       ]
+  #     end
+  #
+  # @example Creating Format-specific commands:
+  #   class Format
+  #     def self.cli_commands
+  #       {
+  #         count: ->(argv, opts) do
+  #           count = 0
+  #           RDF::CLI.parse(argv, opts) do |reader|
+  #             reader.each_statement do |statement|
+  #               count += 1
+  #             end
+  #           end
+  #           $stdout.puts "Parsed #{count} statements"
+  #         end,
+  #       }
+  #     end
+  #
+  # Format-specific commands should verify that the reader and/or output format are appropriate for the command.
   class CLI
 
+    # Option description for use within Readers/Writers. See {RDF::Reader.options} and {RDF::Writer.options} for example usage.
+    class Option
+      # Symbol used for this option when calling `Reader.new`
+      # @return [Symbol]
+      attr_reader :symbol
+
+      # Arguments passed to OptionParser#on
+      # @return [Array<String>]
+      attr_reader :on
+
+      # Description of this option (optional)
+      # @return [String]
+      attr_reader :description
+
+      # Argument datatype, which may be enumerated string values
+      # @return [Class, Array<String>]
+      attr_reader :datatype
+
+      # Allows multiple comma-spearated values.
+      # @return [Boolean]
+      attr_reader :multiple
+
+      ##
+      # Create a new option with optional callback.
+      #
+      # @param [Symbol] symbol
+      # @param [Array<String>] on
+      # @param [String] description
+      # @param [Class, Array<String>] datatype of value
+      # @param [Boolean] multiple can have multiple comma-separated values
+      # @yield value which may be used within `OptionParser#on`
+      # @yieldparam [Object] value The option value as parsed using `on` argument
+      # @yieldreturn [Object] a possibly modified input value
+      def initialize(symbol: nil, on: nil, description: nil, datatype: String, multiple: false, &block)
+        raise ArgumentError, "symbol is a required argument" unless symbol
+        raise ArgumentError, "on is a required argument" unless on
+        @symbol, @on, @description, @datatype, @multiple, @callback = symbol.to_sym, Array(on), description, datatype, multiple, block
+      end
+
+      def call(arg)
+        @callback ? @callback.call(arg) : arg
+      end
+    end
+
+    # @private
     COMMANDS = {
-      "count"       => lambda do |argv, opts|
+      count: ->(argv, opts) do
         start = Time.new
         count = 0
         self.parse(argv, opts) do |reader|
@@ -35,14 +118,17 @@ module RDF
         secs = Time.new - start
         $stdout.puts "Parsed #{count} statements with #{@readers.join(', ')} in #{secs} seconds @ #{count/secs} statements/second."
       end,
-      "lenghts"     => lambda do |argv, opts|
+      help: ->(argv, opts) do
+        self.usage(self.options)
+      end,
+      lenghts: ->(argv, opts) do
         self.parse(argv, opts) do |reader|
           reader.each_statement do |statement|
             $stdout.puts statement.to_s.size
           end
         end
       end,
-      "objects"     => lambda do |argv, opts|
+      objects: ->(argv, opts) do
         $stdout.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
         self.parse(argv, opts) do |reader|
           reader.each_statement do |statement|
@@ -50,7 +136,7 @@ module RDF
           end
         end
       end,
-      "predicates"   => lambda do |argv, opts|
+      predicates: ->(argv, opts) do
         $stdout.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
         self.parse(argv, opts) do |reader|
           reader.each_statement do |statement|
@@ -58,7 +144,7 @@ module RDF
           end
         end
       end,
-      "serialize" => lambda do |argv, opts|
+      serialize: ->(argv, opts) do
         writer_class = RDF::Writer.for(opts[:output_format]) || RDF::NTriples::Writer
         out = opts[:output] || $stdout
         out.set_encoding(Encoding::UTF_8) if out.respond_to?(:set_encoding) && RUBY_PLATFORM == "java"
@@ -70,13 +156,26 @@ module RDF
           end
         end
       end,
-      "subjects"   => lambda do |argv, opts|
+      subjects: ->(argv, opts) do
         $stdout.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
         self.parse(argv, opts) do |reader|
           reader.each_statement do |statement|
             $stdout.puts statement.subject.to_ntriples
           end
         end
+      end,
+      validate: ->(argv, opts) do
+        start = Time.new
+        count = 0
+        valid = true
+        self.parse(argv, opts) do |reader|
+          reader.each_statement do |statement|
+            count += 1
+            valid = false if statement.invalid?
+          end
+        end
+        secs = Time.new - start
+        $stdout.puts "Validated #{count} statements with #{@readers.join(', ')} in #{secs} seconds @ #{count/secs} statements/second."
       end
     }
 
@@ -90,17 +189,36 @@ module RDF
     # @return [OptionParser]
     def self.options(&block)
       options = OptionParser.new
+      logger = Logger.new($stderr)
+      logger.level = Logger::ERROR
+      logger.formatter = lambda {|severity, datetime, progname, msg| "#{severity} #{msg}\n"}
       opts = options.options = {
-        base_uri:       nil,
-        canonicalize:   false,
         debug:          false,
         evaluate:       nil,
         format:         nil,
         output:         $stdout,
         output_format:  :ntriples,
-        validate:       false,
+        logger:         logger
       }
 
+      # Add default Reader and Writer options
+      RDF::Reader.options.each do |cli_opt|
+        next if opts.has_key?(cli_opt.symbol)
+        on_args = cli_opt.on || []
+        on_args << cli_opt.description if cli_opt.description
+        options.on(*on_args) do |arg|
+          opts[cli_opt.symbol] = cli_opt.call(arg)
+        end
+      end
+      RDF::Writer.options.each do |cli_opt|
+        next if opts.has_key?(cli_opt.symbol)
+        on_args = cli_opt.on || []
+        on_args << cli_opt.description if cli_opt.description
+        options.on(*on_args) do |arg|
+          opts[cli_opt.symbol] = cli_opt.call(arg)
+        end
+      end
+
       # Command-specific options
       if block_given?
         case block.arity
@@ -110,19 +228,28 @@ module RDF
       end
       options.banner ||= "Usage: #{self.basename} [options] command [args...]"
 
-      options.on('--canonicalize', 'Canonicalize input.') do
-        opts[:canonicalize] = true
-      end
-
       options.on('-d', '--debug',   'Enable debug output for troubleshooting.') do
-        opts[:debug] = $DEBUG = true
+        opts[:logger].level = Logger::DEBUG
       end
 
       options.on("-e", "--evaluate STRING", "Evaluate argument as RDF input, if no files are specified") do |arg|
         opts[:evaluate] = arg
       end
 
-      options.on("--input-format FORMAT", "Format of input file, uses heuristic if not specified") do |arg|
+      options.on("--input-format FORMAT", "--format FORMAT", "Format of input file, uses heuristic if not specified") do |arg|
+        unless reader = RDF::Reader.for(arg.downcase.to_sym)
+          self.abort "No reader found for #{arg.downcase.to_sym}. Available readers:\n  #{self.formats(reader: true).join("\n  ")}"
+        end
+
+        # Add format-specific reader options
+        reader.options.each do |cli_opt|
+          next if opts.has_key?(cli_opt.symbol)
+          on_args = cli_opt.on || []
+          on_args << cli_opt.description if cli_opt.description
+          options.on(*on_args) do |arg|
+            opts[cli_opt.symbol] = cli_opt.call(arg)
+          end
+        end
         opts[:format] = arg.downcase.to_sym
       end
 
@@ -131,21 +258,24 @@ module RDF
       end
 
       options.on("--output-format FORMAT", "Format of output file, defaults to NTriples") do |arg|
-        opts[:output_format] = arg.downcase.to_sym
-      end
-
-      options.on('--uri URI', 'Base URI of input file, defaults to the filename.') do |arg|
-        opts[:base_uri] = arg
-      end
+        unless writer = RDF::Writer.for(arg.downcase.to_sym)
+          self.abort "No writer found for #{arg.downcase.to_sym}. Available writers:\n  #{self.formats(writer: true).join("\n  ")}"
+        end
 
-      options.on('--validate', 'Validate input file.') do
-        opts[:validate] = true
+        # Add format-specific writer options
+        writer.options.each do |cli_opt|
+          next if opts.has_key?(cli_opt.symbol)
+          on_args = cli_opt.on || []
+          on_args << cli_opt.description if cli_opt.description
+          options.on(*on_args) do |arg|
+            opts[cli_opt.symbol] = cli_opt.call(arg)
+          end
+        end
+        opts[:output_format] = arg.downcase.to_sym
       end
 
       options.on_tail("-h", "--help", "Show this message") do
-        $stdout.puts options
-        $stdout.puts "Available commands:\n\t#{self.commands.join("\n\t")}"
-        exit
+        self.usage(options)
       end
 
       begin
@@ -158,25 +288,57 @@ module RDF
     end
 
     ##
-    # @param  [String] command
+    # Output usage message
+    def self.usage(options)
+      $stdout.puts options
+      $stdout.puts "Note: available commands and options may be different depending on selected --input-format and/or --output-format."
+      $stdout.puts "Available commands:\n\t#{self.commands.join("\n\t")}"
+      $stdout.puts "Available formats:\n\t#{(self.formats).join("\n\t")}"
+    end
+
+    ##
+    # @param  [#to_sym] command
     # @param  [Array<String>] args
     # @return [Boolean]
     def self.exec_command(command, args, options = {})
-      unless COMMANDS.has_key?(command)
-        abort "#{File.basename($0)}: unknown command `#{command}'"
+      unless commands.include?(command.to_s)
+        abort "unknown command `#{command}'"
       end
 
-      COMMANDS[command].call(args, options)
+      COMMANDS[command.to_sym].call(args, options)
+    rescue ArgumentError => e
+      abort e.message
     end
 
     ##
     # @return [Array<String>] list of executable commands
     def self.commands
-      COMMANDS.keys
+      # First, load commands from other formats
+      unless @commands_loaded
+        RDF::Format.each do |format|
+          format.cli_commands.each do |command, lambda|
+            COMMANDS[command] ||= lambda
+          end
+        end
+        @commands_loaded = true
+      end
+      COMMANDS.keys.map(&:to_s).sort
+    end
+
+    ##
+    # @return [Array<String>] list of available formats
+    def self.formats(reader: false, writer: false)
+      f = RDF::Format.each.
+        select {|f| (reader ? f.reader : (writer ? f.writer : true))}.
+        inject({}) do |memo, reader|
+          memo.merge(reader.to_sym => reader.name)
+      end
+      sym_len = f.keys.map {|k| k.to_s.length}.max
+      f.map {|s, t| "%*s: %s" % [sym_len, s, t]}
     end
 
     ##
-    # Parse each file, STDIN or specified string in `options[:evaluate]`
+    # Parse each file, $stdin or specified string in `options[:evaluate]`
     # yielding a reader
     #
     # @param  [Array<String>] files
@@ -186,7 +348,7 @@ module RDF
     def self.parse(files, options = {}, &block)
       if files.empty?
         # If files are empty, either use options[:execute]
-        input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
+        input = options[:evaluate] ? StringIO.new(options[:evaluate]) : $stdin
         input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
         RDF::Reader.for(options[:format] || :ntriples).new(input, options) do |reader|
           yield(reader)