Release 1.99.0:

* Warn when a deprecated vocabulary constant is found that it is deprecated, and that the access pattern will change. Fixes #191.
* RDF.rb 2.0 will deprecate the use of `context` in favor of `graph_name`. This affects many methods, but also :context used as an option. For issue #189.
* Change `#has_blank_nodes?` to `#node?`, but keep as method alias.
* Add `Term#compatible?` from SPARQL.
* Add a `#valid?` implementation to Reader base.
* Fix issues converting DateTime and Time objects to strings when not canonicalizing. Fixes #218.
* Fix named graph support in `RDF::Transaction`
  * Use of `RDF::Graph` to store inserts and deletes in `RDF::Transaction` is heavy handed, and results in the destruction of graph names on statements passed in. This fix simply uses `[]` to handle the statement lists (`RDF::Enumerable` is already included by force).
  * This should be cheaper and insulate us from potentially unwanted behavior outside of `Enumerable`. Clients can still use `RDF::Graph` by passing it on initialization at their own risk.
* Correct behaviors for open_file:
  * charset should be a downcased string. Fixes #199.
  * content_encoding reflects Content-Encoding, as an array of downcased strings.
  * Non-UTF input is transformed to UTF-8, so that `external_encoding` is now "utf-8" with `charset` the original character set.
  * With Ruby 2.2+, attempt to turn Unicode input into NFC.
* Make `Transaction#execute` more atomic
  * Executing a transaction individually called `#delete` or `#insert` for each statement in the changeset. This prevents using the features of `Repositories` with a more efficient implementation of `#insert/delete_statements`.
* Use `#clear_statements` when available
  * `Mutable#clear` checks whether the instance responds to `#clear_statements` and falls back on `#delete_statements`. The former clears the entire mutable, using e.g., `graph_name`, while the later has enumerative semantics (deleting the members of the set of statements). Because `#clear_statements` is protected or private, it will never be used by immutable without the `true` flag on `#respond_to?`.
* Add `Statement.#complete?/#incomplete?` to check for nil elements. Update `Repository#insert_statement` to not add incomplete statements (silently); raises an ArgumentError. For #226.

Author: gkellogg

Gemfile

@@ -4,10 +4,14 @@ gemspec
 
 group :develop do
   gem "rdf-spec",       git: "git://github.com/ruby-rdf/rdf-spec.git", branch: "develop"
+  gem "rdf-vocab",      git: "git://github.com/ruby-rdf/rdf-vocab.git", branch: "develop"
   gem 'linkeddata',     git: "git://github.com/ruby-rdf/linkeddata.git", branch: "develop"
+  gem 'rdf-aggregate-repo', git: "git://github.com/ruby-rdf/rdf-aggregate-repo.git", branch: "develop"
+  gem 'rdf-isomorphic', git: "git://github.com/ruby-rdf/rdf-isomorphic.git", branch: "develop"
   gem 'rdf-n3',         git: "git://github.com/ruby-rdf/rdf-n3.git", branch: "develop"
   gem "rdf-rdfxml",     git: "git://github.com/ruby-rdf/rdf-rdfxml.git", branch: "develop"
   gem 'rdf-rdfa',       git: "git://github.com/ruby-rdf/rdf-rdfa.git", branch: "develop"
+  gem 'rdf-trig',       git: "git://github.com/ruby-rdf/rdf-trig.git", branch: "develop"
   gem 'rdf-turtle',     git: "git://github.com/ruby-rdf/rdf-turtle.git", branch: "develop"
   gem 'rdf-microdata',  git: "git://github.com/ruby-rdf/rdf-microdata.git", branch: "develop"
   gem "rdf-xsd",        git: "git://github.com/ruby-rdf/rdf-xsd.git", branch: "develop"
@@ -19,13 +23,13 @@ group :develop do
 end
 
 group :debug do
-  gem 'psych', :platforms => [:mri, :rbx]
+  gem 'psych', platforms: [:mri, :rbx]
   gem "wirble"
-  gem "redcarpet", :platforms => :ruby
-  gem "debugger", :platforms => :mri_19
-  gem "byebug", :platforms => :mri
-  gem "ruby-debug", :platforms => :jruby
-  gem "pry", :platforms => :rbx
+  gem "redcarpet", platforms: :ruby
+  gem "debugger", platforms: :mri_19
+  gem "byebug", platforms: :mri
+  gem "ruby-debug", platforms: :jruby
+  gem "pry", platforms: :rbx
   gem 'guard-rspec'
 end
 

README.md

@@ -92,7 +92,7 @@ operations on RDF files using available readers and writers.
 ### Writing RDF data using the [N-Triples][] format
 
     require 'rdf/ntriples'
-    graph = RDF::Graph.new << [:hello, RDF::DC.title, "Hello, world!"]
+    graph = RDF::Graph.new << [:hello, RDF::RDFS.label, "Hello, world!"]
     graph.dump(:ntriples)
 
 or
@@ -114,13 +114,13 @@ or
 
 ### Reading RDF data in other formats
 {RDF::Reader.open} and {RDF::Repository.load} use a number of mechanisms to determine the appropriate reader
-to use when loading a file. The specific format to use can be forced using, e.g. `:format => :ntriples`
+to use when loading a file. The specific format to use can be forced using, e.g. `format: :ntriples`
 option where the specific format symbol is determined by the available readers. Both also use
 MimeType or file extension, where available.
 
     require 'rdf/nquads'
 
-    graph = RDF::Graph.load("http://ruby-rdf.github.com/rdf/etc/doap.nq", :format => :nquads)
+    graph = RDF::Graph.load("http://ruby-rdf.github.com/rdf/etc/doap.nq", format: :nquads)
 
 A specific sub-type of Reader can also be invoked directly:
 
@@ -144,24 +144,24 @@ appropriate writer to use.
 
     require 'linkeddata'
 
-    RDF::Writer.open("hello.nq", :format => :nquads) do |writer|
+    RDF::Writer.open("hello.nq", format: :nquads) do |writer|
       writer << RDF::Repository.new do |repo|
-        repo << RDF::Statement.new(:hello, RDF::DC.title, "Hello, world!", :context => RDF::URI("context"))
+        repo << RDF::Statement.new(:hello, RDF::RDFS.label, "Hello, world!", context: RDF::URI("context"))
       end
     end
 
 A specific sub-type of Writer can also be invoked directly:
 
     require 'rdf/nquads'
 
-    repo = RDF::Repository.new << RDF::Statement.new(:hello, RDF::DC.title, "Hello, world!", :context => RDF::URI("context"))
+    repo = RDF::Repository.new << RDF::Statement.new(:hello, RDF::RDFS.label, "Hello, world!", context: RDF::URI("context"))
     File.open("hello.nq", "w") {|f| f << repo.dump(:nquads)}
 
 ## Reader/Writer convenience methods
 {RDF::Enumerable} implements `to_{format}` for each available instance of {RDF::Reader}.
 For example, if `rdf/turtle` is loaded, this allows the following:
 
-    graph = RDF::Graph.new << [:hello, RDF::DC.title, "Hello, world!"]
+    graph = RDF::Graph.new << [:hello, RDF::RDFS.label, "Hello, world!"]
     graph.to_ttl
 
 Similarly, {RDF::Mutable} implements `from_{format}` for each available instance
@@ -172,15 +172,15 @@ of {RDF::Writer}. For example:
 
 Note that no prefixes are loaded automatically, however they can be provided as arguments:
 
-    graph.from_ttl("[ a rdf:Resource]", :prefixes => {:rdf => RDF.to_uri})
+    graph.from_ttl("[ a rdf:Resource]", prefixes: {rdf: RDF.to_uri})
 
 ### Querying RDF data using basic graph patterns (BGPs)
 
     require 'rdf/ntriples'
 
     graph = RDF::Graph.load("http://ruby-rdf.github.com/rdf/etc/doap.nt")
     query = RDF::Query.new({
-      :person => {
+      person: {
         RDF.type  => FOAF.Person,
         FOAF.name => :name,
         FOAF.mbox => :email,

Rakefile

@@ -16,8 +16,8 @@ namespace :gem do
 end
 
 desc 'Default: run specs.'
-task :default => :spec
-task :specs => :spec
+task default: :spec
+task specs: :spec
 
 require 'rspec/core/rake_task'
 desc 'Run specifications'
@@ -99,7 +99,7 @@ vocab_sources = {
            strict: false},
 }
 
-task :gen_vocabs => vocab_sources.keys.map {|v| "lib/rdf/vocab/#{v}.rb"}
+task gen_vocabs: vocab_sources.keys.map {|v| "lib/rdf/vocab/#{v}.rb"}
 
 vocab_sources.each do |id, v|
   file "lib/rdf/vocab/#{id}.rb" => :do_build do

VERSION

@@ -1 +1 @@
-1.1.17.1
+1.99.0

etc/Gemfile

@@ -1,28 +1,28 @@
 source 'http://rubygems.org'
 
-gem 'rdf',            :git => 'git://github.com/ruby-rdf/rdf.git'
-gem 'rdf-do',         :git => 'git://github.com/ruby-rdf/rdf-do.git'
-gem 'rdf-isomorphic', :git => 'git://github.com/ruby-rdf/rdf-isomorphic.git'
-gem 'rdf-json',       :git => 'git://github.com/ruby-rdf/rdf-json.git'
-gem 'rdf-mongo',      :git => 'git://github.com/ruby-rdf/rdf-mongo.git'
-gem 'rdf-n3',         :git => 'git://github.com/ruby-rdf/rdf-n3.git'
-gem 'rdf-n3',         :git => 'git://github.com/ruby-rdf/rdf-trig.git'
-gem 'rdf-n3',         :git => 'git://github.com/ruby-rdf/rdf-turtle.git'
-gem 'rdf-rdfa',       :git => 'git://github.com/ruby-rdf/rdf-rdfa.git'
-gem 'rdf-rdfxml',     :git => 'git://github.com/ruby-rdf/rdf-rdfxml.git'
-gem 'rdf-spec',       :git => 'git://github.com/ruby-rdf/rdf-spec.git'
-gem 'rdf-trix',       :git => 'git://github.com/ruby-rdf/rdf-trix.git'
+gem 'rdf',            git: 'git://github.com/ruby-rdf/rdf.git'
+gem 'rdf-do',         git: 'git://github.com/ruby-rdf/rdf-do.git'
+gem 'rdf-isomorphic', git: 'git://github.com/ruby-rdf/rdf-isomorphic.git'
+gem 'rdf-json',       git: 'git://github.com/ruby-rdf/rdf-json.git'
+gem 'rdf-mongo',      git: 'git://github.com/ruby-rdf/rdf-mongo.git'
+gem 'rdf-n3',         git: 'git://github.com/ruby-rdf/rdf-n3.git'
+gem 'rdf-n3',         git: 'git://github.com/ruby-rdf/rdf-trig.git'
+gem 'rdf-n3',         git: 'git://github.com/ruby-rdf/rdf-turtle.git'
+gem 'rdf-rdfa',       git: 'git://github.com/ruby-rdf/rdf-rdfa.git'
+gem 'rdf-rdfxml',     git: 'git://github.com/ruby-rdf/rdf-rdfxml.git'
+gem 'rdf-spec',       git: 'git://github.com/ruby-rdf/rdf-spec.git'
+gem 'rdf-trix',       git: 'git://github.com/ruby-rdf/rdf-trix.git'
 
-gem 'rdf-arq',        :git => 'git://github.com/bendiken/rdf-arq.git'
-gem 'rdf-bert',       :git => 'git://github.com/bendiken/rdf-bert.git'
-gem 'rdf-cassandra',  :git => 'git://github.com/bendiken/rdf-cassandra.git'
-gem 'rdf-raptor',     :git => 'git://github.com/bendiken/rdf-raptor.git'
-gem 'rdf-rasqal',     :git => 'git://github.com/bendiken/rdf-rasqal.git'
-gem 'rdf-sesame',     :git => 'git://github.com/bendiken/rdf-sesame.git'
+gem 'rdf-arq',        git: 'git://github.com/bendiken/rdf-arq.git'
+gem 'rdf-bert',       git: 'git://github.com/bendiken/rdf-bert.git'
+gem 'rdf-cassandra',  git: 'git://github.com/bendiken/rdf-cassandra.git'
+gem 'rdf-raptor',     git: 'git://github.com/bendiken/rdf-raptor.git'
+gem 'rdf-rasqal',     git: 'git://github.com/bendiken/rdf-rasqal.git'
+gem 'rdf-sesame',     git: 'git://github.com/bendiken/rdf-sesame.git'
 
-gem 'rdf-talis',      :git => 'git://github.com/bhuga/rdf-talis.git'
+gem 'rdf-talis',      git: 'git://github.com/bhuga/rdf-talis.git'
 
-gem 'rdf-n3',         :git => 'git://github.com/gkellogg/json-ld.git'
+gem 'rdf-n3',         git: 'git://github.com/gkellogg/json-ld.git'
 
-gem 'rdf-4store',     :git => 'git://github.com/fumi/rdf-4store.git'
-gem 'rdf-redstore',   :git => 'git://github.com/njh/rdf-redstore.git'
+gem 'rdf-4store',     git: 'git://github.com/fumi/rdf-4store.git'
+gem 'rdf-redstore',   git: 'git://github.com/njh/rdf-redstore.git'

examples/query_bench.rb

@@ -2,15 +2,16 @@
 
 require 'benchmark'
 require 'rdf'
+require 'rdf/vocab'
 require 'rdf/ntriples'
 graph = RDF::Graph.load("etc/doap.nt")
 
-puts graph.query(:predicate => RDF::FOAF.name).is_a?(RDF::Queryable)
+puts graph.query(predicate: RDF::Vocab::FOAF.name).is_a?(RDF::Queryable)
 
 Benchmark.bmbm do |bench|
   bench.report("query_pattern") do
     100_000.times do
-      graph.query(:predicate => RDF::FOAF.name) {}
+      graph.query(predicate: RDF::Vocab::FOAF.name) {}
     end
   end
 end

lib/rdf.rb

@@ -55,7 +55,20 @@ module RDF
   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 []
-  VOCABS.each { |v| autoload v.to_s.upcase.to_sym, "rdf/vocab/#{v}" unless v == :rdf }
+
+  # 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)
+      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}"
+      const_get(constant)
+    else
+      super
+    end
+  end
 
   # Utilities
   autoload :Util,        'rdf/util'
@@ -152,15 +165,17 @@ def self.List(*args)
   #   @option options [RDF::URI]       :predicate (nil)
   #   @option options [RDF::Term]      :object    (nil)
   #   @option options [RDF::Resource]  :context   (nil)
-  #     Note, in RDF 1.1, a context MUST be an IRI.
+  #     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]
   #
   # @overload Statement(subject, predicate, object, options = {})
   #   @param  [RDF::Resource]          subject
   #   @param  [RDF::URI]               predicate
   #   @param  [RDF::Term]              object
   #   @param  [Hash{Symbol => Object}] options
-  #   @option options [RDF::Resource]  :context   (nil)
+  #   @option options [RDF::Resource]  :graph_name   (nil)
   #   @return [RDF::Statement]
   #
   def self.Statement(*args)
@@ -203,7 +218,7 @@ def self.respond_to?(method, include_all = false)
   end
 
   ##
-  # Delegate other methods to RDF::RDF
+  # Delegate other methods to RDF::RDFV
   def self.method_missing(property, *args, &block)
     if args.empty?
       # Special-case rdf:_n for all integers

lib/rdf/cli.rb

@@ -62,8 +62,8 @@ class CLI
         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"
-        opts = opts.merge(:prefixes => {})
-        writer_opts = opts.merge(:standard_prefixes => true)
+        opts = opts.merge(prefixes: {})
+        writer_opts = opts.merge(standard_prefixes: true)
         self.parse(argv, opts) do |reader|
           writer_class.new(out, writer_opts) do |writer|
             writer << reader
@@ -91,14 +91,14 @@ def self.basename() File.basename($0) end
     def self.options(&block)
       options = OptionParser.new
       opts = options.options = {
-        :base_uri       => nil,
-        :canonicalize   => false,
-        :debug          => false,
-        :evaluate       => nil,
-        :format         => nil,
-        :output         => $stdout,
-        :output_format  => :ntriples,
-        :validate       => false,
+        base_uri:       nil,
+        canonicalize:   false,
+        debug:          false,
+        evaluate:       nil,
+        format:         nil,
+        output:         $stdout,
+        output_format:  :ntriples,
+        validate:       false,
       }
 
       # Command-specific options

lib/rdf/format.rb

@@ -11,19 +11,19 @@ module RDF
   # @example Getting a serialization format class
   #   RDF::Format.for(:ntriples)     #=> RDF::NTriples::Format
   #   RDF::Format.for("etc/doap.nt")
-  #   RDF::Format.for(:file_name => "etc/doap.nt")
-  #   RDF::Format.for(:file_extension => "nt")
-  #   RDF::Format.for(:content_type => "application/n-triples")
+  #   RDF::Format.for(file_name: "etc/doap.nt")
+  #   RDF::Format.for(file_extension: "nt")
+  #   RDF::Format.for(content_type: "application/n-triples")
   #
   # @example Obtaining serialization format MIME types
   #   RDF::Format.content_types      #=> {"application/n-triples" => [RDF::NTriples::Format]}
   #
   # @example Obtaining serialization format file extension mappings
-  #   RDF::Format.file_extensions    #=> {:nt => [RDF::NTriples::Format]}
+  #   RDF::Format.file_extensions    #=> {nt: [RDF::NTriples::Format]}
   #
   # @example Defining a new RDF serialization format class
   #   class RDF::NTriples::Format < RDF::Format
-  #     content_type     'application/n-triples', :extension => :nt
+  #     content_type     'application/n-triples', extension: :nt
   #     content_encoding 'utf-8'
   #     
   #     reader RDF::NTriples::Reader
@@ -95,7 +95,7 @@ def self.for(options = {})
       format = case options
         when String
           # Find a format based on the file name
-          self.for(:file_name => options) { yield if block_given? }
+          self.for(file_name: options) { yield if block_given? }
 
         when Hash
           case
@@ -112,7 +112,7 @@ def self.for(options = {})
               content_types[mime_type] unless mime_type == 'text/plain' && (options[:sample] || block_given?)
             # Find a format based on the file name:
             when file_name = options[:file_name]
-              self.for(:file_extension => File.extname(file_name.to_s)[1..-1]) { yield if block_given? }
+              self.for(file_extension: File.extname(file_name.to_s)[1..-1]) { yield if block_given? }
             # Find a format based on the file extension:
             when file_ext  = options[:file_extension]
               file_extensions[file_ext.to_sym]
@@ -201,7 +201,7 @@ def self.reader_symbols
     # @example
     #
     #     content_types = RDF::Format.reader_types
-    #     format = RDF::Format.for(:content_type => content_types.first)
+    #     format = RDF::Format.for(content_type: content_types.first)
     #
     # @return [Array<String>]
     def self.reader_types
@@ -227,7 +227,7 @@ def self.writer_symbols
     # @example
     #
     #     content_types = RDF::Format.writer_types
-    #     format = RDF::Format.for(:content_type => content_types.first)
+    #     format = RDF::Format.for(content_type: content_types.first)
     #
     # @return [Array<String>]
     def self.writer_types