rdf 1.1.0p4 → 1.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YzQwOTc4Mjk1Y2NmOWMzODIzZjFiNTdhNzYyZWUxOTYwOGFjNTdiMw==
-  data.tar.gz: !binary |-
-    M2NiZTBiYzljOTBiNDkzMmMzODI5NWJjZGFiNmViYzkxNzNhNjZjNg==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    NmU4YjMwMzUxMmNjZTViYWNjZTQ2ZjU1MzdjZWRmYzY1ZmQ2OTUyYzU0N2Zm
-    YzYzYmY5Y2FkMmY3MjVjNzUyZjZhOTc2MWUyOWI4NTgwN2Q3MzA4ZjJjNTk0
-    MmUzOTNhNGU3ZTY3NjI4NzQ2NTllMzk1YjliZjljNzA4ZDQzM2I=
-  data.tar.gz: !binary |-
-    MGY0NzJjZTJmM2M0YjQ1ZTRmM2UyYTBiM2RmYjBlZWNmMzZiZjE5ZDkxYWVm
-    NzMxZTE4MDUxYWZhYTc3MDhkODQ3NTY3YzNiNTZkNzQ3ZWVjODFkYzVkMDAz
-    YjA2ZjkyOTU5YjI1NzlhY2U3OGYzZTU2YmUzMDhiM2ExZmVmMjI=
+SHA1:
+  metadata.gz: 636560fdd9893b6be15ec6aa259dde6b2af2c86e
+  data.tar.gz: af38349d48ebb7fd97aa7b20942a2dbb380b3b80
+SHA512:
+  metadata.gz: 36b838c62356a7d6d7d31efb4246e1d24e5ee277f79f41f94ed5f908b64e310312387e711e7f14b7b4cfdce79c3f135b164c1f8c4d057a505c320e6799fda7be
+  data.tar.gz: 19318c68a807d1f9f3e6d9c3857c48a40ca99e51124d308b0604cdecf147fd5c37e65751845d16e491ca5f0965857881704f3faf690666ed800e43aa1218fad4

data/README

@@ -38,36 +38,26 @@ This version of RDF.rb is fully compatible with [RDF 1.1][], but it creates some
 marginal incompatibilities with [RDF 1.0][], as implemented in versions prior to
 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::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}, {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::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}.
-* 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.
+* 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}, {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}.
+* 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}.
+* {RDF::Util::File.open\_file} now performs redirects and manages `base_uri` based on W3C recommendations:
+  * `base_uri` is set to the original URI if a status 303 is provided, otherwise any other redirect will set `base_uri` to the redirected location.
+  * `base_uri` is set to the content of the `Location` header if status is _success_.
+* Additionally, {RDF::Util::File.open\_file} sets the result encoding from `charset` if provided, defaulting to `UTF-8`. Other access methods include `last_modified` and `content_type`, 
+* {RDF::StrictVocabulary} added with an easy way to keep vocabulary definitions up to date based on their OWL or RDFS definitions. Most vocabularies are now StrictVocabularies meaning that an attempt to resolve a particular term in that vocabulary will error if the term is not defined in the vocabulary.
+* New vocabulary definitions have been added for [ICal](http://www.w3.org/2002/12/cal/icaltzd#), [Media Annotations (MA)](http://www.w3.org/ns/ma-ont#), [Facebook OpenGraph (OG)](http://ogp.me/ns#), [PROV](http://www.w3.org/ns/prov#), [SKOS-XL (SKOSXL)](http://www.w3.org/2008/05/skos-xl#), [Data Vocabulary (V)](http://rdf.data-vocabulary.org/), [VCard](http://www.w3.org/2006/vcard/ns#), [VOID](http://rdfs.org/ns/void#http://rdfs.org/ns/void#), [Powder-S (WDRS)](http://www.w3.org/2007/05/powder-s#), and [XHV](http://www.w3.org/1999/xhtml/vocab#).
+
+Notably, {RDF::Queryable#query} and {RDF::Query#execute} are now completely symmetric; this allows an implementation of {RDF::Queryable} to optimize queries using implementation-specific logic, allowing for substantial performance improvements when executing BGP queries.
 
 ## Tutorials
 
@@ -188,10 +178,18 @@ Note that no prefixes are loaded automatically, however they can be provided as
       }
     })
     
-    query.execute(graph).each do |solution|
+    query.execute(graph) do |solution|
       puts "name=#{solution.name} email=#{solution.email}"
     end
 
+The same query may also be run from the graph:
+
+    graph.query(query) do |solution|
+      puts "name=#{solution.name} email=#{solution.email}"
+    end
+
+In general, querying from using the `queryable` instance allows a specific implementation of `queryable` to perform query optimizations specific to the datastore on which it is based.
+
 A separate [SPARQL][SPARQL doc] gem builds on basic BGP support to provide full support for [SPARQL 1.0](http://www.w3.org/TR/rdf-sparql-query/) queries.
 
 ### Using pre-defined RDF vocabularies
@@ -373,7 +371,7 @@ follows:
 
 * [Arto Bendiken](http://github.com/bendiken) - <http://ar.to/>
 * [Ben Lavender](http://github.com/bhuga) - <http://bhuga.net/>
-* [Gregg Kellogg](http://github.com/gkellogg) - <http://kellogg-assoc.com/>
+* [Gregg Kellogg](http://github.com/gkellogg) - <http://greggkellogg.net/>
 
 ## Contributors
 
@@ -392,6 +390,8 @@ follows:
 
 ## Contributing
 
+This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange development and release activity. All submissions _must_ be on a feature branch based on the _develop_ branch to ease staging and integration.
+
 * 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.
   Before committing, run `git diff --check` to make sure of this.
@@ -419,7 +419,7 @@ see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [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/gkellogg/json-ld/frames
+[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
 [N3 doc]:           http://rubydoc.info/github/ruby-rdf/rdf-n3/master/frames

data/VERSION

@@ -1 +1 @@
-1.1.0p4
+1.1.0

data/lib/rdf.rb

@@ -1,5 +1,3 @@
-require 'enumerator'
-require 'open-uri'
 require 'stringio'
 require 'bigdecimal'
 require 'date'
@@ -55,6 +53,7 @@ module RDF
 
   # RDF vocabularies
   autoload :Vocabulary,  'rdf/vocab'
+  autoload :StrictVocabulary,  'rdf/vocab'
   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 }
 
@@ -116,12 +115,60 @@ module RDF
   end
 
   ##
-  # Alias for `RDF::Statement.new`.
+  # @overload List()
+  #   @return [RDF::URI] returns the IRI for `rdf:List`
   #
-  # @param (see RDF::Statement#initialize)
-  # @return [RDF::Statement]
-  def self.Statement(*args, &block)
-    Statement.new(*args, &block)
+  # @overload List(*args)
+  #   @param (see RDF::List#[])
+  #   @return [RDF::List]
+  #
+  # @overload List(array)
+  #   @param [Array] array
+  #   @return [RDF::List]
+  #
+  # @overload List(list)
+  #   @param [RDF::List] list
+  #   @return [RDF::List] returns itself
+  def self.List(*args)
+    case
+    when args.empty?
+      RDF[:List]
+    when args.length == 1 && args.first.is_a?(RDF::List)
+      args.first
+    when args.length == 1 && args.first.is_a?(Array)
+      List[*args.first]
+    else
+      List[*args]
+    end
+  end
+
+  ##
+  # @overload Statement()
+  #   @return [RDF::URI] returns the IRI for `rdf:Statement`
+  #
+  # @overload Statement(options = {})
+  #   @param  [Hash{Symbol => Object}] options
+  #   @option options [RDF::Resource]  :subject   (nil)
+  #   @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.
+  #   @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)
+  #   @return [RDF::Statement]
+  #
+  def self.Statement(*args)
+    if args.empty?
+      RDF[:Statement]
+    else
+      Statement.new(*args)
+    end
   end
 
   ##
@@ -134,9 +181,12 @@ module RDF
   end
 
   ##
-  # @return [URI]
-  def self.value
-    self[:value]
+  # Alias for `RDF::StrictVocabulary.create`.
+  #
+  # @param (see RDF::Vocabulary#initialize)
+  # @return [Class]
+  def self.StrictVocabulary(prefix)
+    StrictVocabulary.create(prefix)
   end
 
   ##
@@ -177,14 +227,12 @@ module RDF
     first
     HTML
     langString
-    List
     nil
     object
     predicate
     Property
     rest
     Seq
-    Statement
     subject
     type
     value

data/lib/rdf/cli.rb

@@ -6,7 +6,13 @@ begin
   gem 'linkeddata'
   require 'linkeddata'
 rescue LoadError
-  # Silently load without linkeddata
+  # Silently load without linkeddata, but try some others
+  %w(rdfa rdfxml turtle).each do |ser|
+    begin
+      require "rdf/#{ser}"
+    rescue LoadError
+    end
+  end
 end
 
 class OptionParser

data/lib/rdf/cli/vocab-loader.rb

@@ -0,0 +1,240 @@
+require 'rdf'
+require 'linkeddata'
+require 'optparse'
+
+module RDF
+  # Utility class to load RDF vocabularies from files or their canonical
+  # definitions and emit either a class file for RDF::StrictVocabulary,
+  # RDF::Vocabulary or the raw RDF vocabulary
+  class VocabularyLoader
+    def initialize(class_name = nil)
+      @class_name = class_name
+      @output = $stdout
+      @output_class_file = true
+      @prefix = nil
+      @url = nil
+      @strict = true
+      @extra = []
+    end
+    attr_accessor :class_name, :output, :output_class_file
+    attr_reader :prefix, :source
+
+    # Set the prefix for the loaded RDF file - by default, sets the source as
+    # well
+    def prefix=(uri)
+      @prefix = uri
+      @source ||= uri
+    end
+
+    # Set the source for the loaded RDF - by default, sets the prefix as well
+    def source=(uri)
+      @source = uri
+      @prefix ||= uri
+    end
+
+    # Set output
+    def output=(out)
+      @output = out
+    end
+
+    # Extra properties to define
+    def extra=(extra)
+      @extra = extra
+    end
+
+    # Use StrictVocabulary or Vocabulary
+    def strict=(strict)
+      @strict = strict
+    end
+
+    # Parses arguments, for use in a command line tool
+    def parse_options(argv)
+      opti = OptionParser.new
+      opti.banner = "Usage: #{File.basename($0)} [options] [prefix [outfile]]\nFetch an RDFS file and produce an RDF::StrictVocabulary with it.\n\n"
+
+      opti.on("--prefix URI", "The prefix for the fetched RDF vocabulary") do |uri|
+        self.prefix = uri
+      end
+
+      opti.on("--source SOURCE", "The source URI or file for the vocabulary") do |uri|
+        self.source = uri
+      end
+
+      opti.on("--class-name NAME", "The class name for the output StrictVocabulary subclass") do |name|
+        self.class_name = name
+      end
+
+      opti.on("--raw", "Don't output an output file - just the RDF") do
+        @output_class_file = false
+      end
+
+      opti.on_tail("--help", "This help text") do
+        $stdout.puts opti
+        exit 1
+      end
+
+      others = opti.parse(argv)
+
+      if @class_name.nil? and @output_class_file
+        raise "Class name (--class-name) is required!"
+      end
+
+      if prefix.nil?
+        self.prefix, outfile, extra = *others
+      else
+        outfile, extra = *others
+      end
+
+      unless outfile.nil?
+        @output = File.open(outfile, "w")
+      end
+
+      unless extra.nil?
+        $stderr.puts "Too many arguments!"
+        $stderr.puts opti
+        exit 1
+      end
+    end
+
+    # Loads the graph
+    def graph
+      @graph ||= RDF::Graph.load(source)
+    end
+
+    # Parse command line arguments and run the load-and-emit process
+    def go(argv)
+      parse_options(argv)
+      run
+
+      if @output != $stdout
+        @output.close
+      end
+    end
+
+    # @private
+    def from_solution(solution)
+      prefix_match = %r{\A#{@prefix}(.*)}
+      return if !solution.resource.uri? || (match = prefix_match.match(solution.resource.to_s)).nil?
+      name = match[1]
+
+      # If there's a label or comment, the must either have no language, or be en
+      label = solution[:label]
+      comment = solution[:comment]
+
+      return if label && label.has_language? && !label.language.to_s.start_with?("en")
+      return if comment && comment.has_language? && !comment.language.to_s.start_with?("en")
+      label = label.to_s.
+        encode(Encoding::US_ASCII). # also force exception if invalid
+        strip.
+        gsub(/\s+/m, ' ')
+      comment = comment.to_s.
+        encode(Encoding::US_ASCII). # also force exception if invalid
+        strip.
+        gsub(/\s+/m, ' ').
+        gsub(/([\(\)])/, '\\\\\\1')
+
+      @output.write "    property #{name.to_sym.inspect}"
+      @output.write ", :label => '#{label}'" unless label.empty?
+      @output.write ", :comment =>\n      %(#{comment.scan(/\S.{0,60}\S(?=\s|$)|\S+/).join("\n        ")})" unless comment.empty?
+      @output.puts
+    rescue Encoding::UndefinedConversionError
+    end
+
+    # Actually executes the load-and-emit process - useful when using this
+    # class outside of a command line - instantiate, set attributes manually,
+    # then call #run
+    def run
+      @output.print %(# This file generated automatically using vocab-fetch from #{source}
+        require 'rdf'
+        module RDF
+          class #{class_name} < #{"Strict" if @strict}Vocabulary("#{prefix}")
+        ).gsub(/^        /, '') if @output_class_file
+
+      classes = RDF::Query.new do
+        pattern [:resource, RDF.type, RDFS.Class]
+        pattern [:resource, RDFS.label, :label], :optional => true
+        pattern [:resource, RDFS.comment, :comment], :optional => true
+      end
+
+      owl_classes = RDF::Query.new do
+        pattern [:resource, RDF.type, OWL.Class]
+        pattern [:resource, RDFS.label, :label], :optional => true
+        pattern [:resource, RDFS.comment, :comment], :optional => true
+      end
+
+      class_defs = graph.query(classes).to_a + graph.query(owl_classes).to_a
+      unless class_defs.empty?
+        @output.puts "\n    # Class definitions"
+        class_defs.sort_by {|s| (s[:label] || s[:resource]).to_s}.each do |klass|
+          from_solution(klass)
+        end
+      end
+
+      properties = RDF::Query.new do
+        pattern [:resource, RDF.type, RDF.Property]
+        pattern [:resource, RDFS.label, :label], :optional => true
+        pattern [:resource, RDFS.comment, :comment], :optional => true
+      end
+
+      dt_properties = RDF::Query.new do
+        pattern [:resource, RDF.type, OWL.DatatypeProperty]
+        pattern [:resource, RDFS.label, :label], :optional => true
+        pattern [:resource, RDFS.comment, :comment], :optional => true
+      end
+
+      obj_properties = RDF::Query.new do
+        pattern [:resource, RDF.type, OWL.ObjectProperty]
+        pattern [:resource, RDFS.label, :label], :optional => true
+        pattern [:resource, RDFS.comment, :comment], :optional => true
+      end
+
+      ann_properties = RDF::Query.new do
+        pattern [:resource, RDF.type, OWL.AnnotationProperty]
+        pattern [:resource, RDFS.label, :label], :optional => true
+        pattern [:resource, RDFS.comment, :comment], :optional => true
+      end
+
+      ont_properties = RDF::Query.new do
+        pattern [:resource, RDF.type, OWL.OntologyProperty]
+        pattern [:resource, RDFS.label, :label], :optional => true
+        pattern [:resource, RDFS.comment, :comment], :optional => true
+      end
+      prop_defs = graph.query(properties).to_a.sort_by {|s| (s[:label] || s[:resource]).to_s}
+      prop_defs += graph.query(dt_properties).to_a.sort_by {|s| (s[:label] || s[:resource]).to_s}
+      prop_defs += graph.query(obj_properties).to_a.sort_by {|s| (s[:label] || s[:resource]).to_s}
+      prop_defs += graph.query(ann_properties).to_a.sort_by {|s| (s[:label] || s[:resource]).to_s}
+      prop_defs += graph.query(ont_properties).to_a.sort_by {|s| (s[:label] || s[:resource]).to_s}
+      unless prop_defs.empty?
+        @output.puts "\n    # Property definitions"
+        prop_defs.each do |prop|
+          from_solution(prop)
+        end
+      end
+
+
+      datatypes = RDF::Query.new do
+        pattern [:resource, RDF.type, RDFS.Datatype]
+        pattern [:resource, RDFS.label, :label], :optional => true
+        pattern [:resource, RDFS.comment, :comment], :optional => true
+      end
+
+      dt_defs = graph.query(datatypes).to_a.sort_by {|s| (s[:label] || s[:resource]).to_s}
+      unless dt_defs.empty?
+        @output.puts "\n    # Datatype definitions"
+        dt_defs.each do |dt|
+          from_solution(dt)
+        end
+      end
+
+      unless @extra.empty?
+        @output.puts "\n    # Extra definitions"
+        @extra.each do |extra|
+          @output.puts "    property #{extra.to_sym.inspect}"
+        end
+      end
+
+      # Query the vocabulary to extract property and class definitions
+      @output.puts "  end\nend" if @output_class_file
+    end
+  end
+end