rdf 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 55eaca604297a43e08c5e5ab9171b1e2ec0beada
-  data.tar.gz: 139cabcf47483e12266822d66882d7a0913ede67
+  metadata.gz: dcb26de738e672fd9328d6f653a98b7171f65805
+  data.tar.gz: da26233652361aaa44fa23fe258d0fbbc666dbf0
 SHA512:
-  metadata.gz: ffc0b6886fa305b29566f4a5f98119bd60ff16359ea7eb6c1768981dabdc809ea6edfbe2569a8de10e101b3f65a312c62a962b739900cc223461665f3194d635
-  data.tar.gz: 97a984581ad73bc752aa3c16f0e11ad85fa1eb8814bcf05434d7b90b83ca6807e794fe1bdf371c294f4c10b1a562ec9827129e655652eb437311c4e6b997d239
+  metadata.gz: da30c447f12e8412899db7ca822097ced698a689384384a698a5c1ea326d6d1faf32c65053d363424c3f4c73460417bf02fbc8cd6d0930c9edaf3667dfe7b6dd
+  data.tar.gz: b4093866aba7ef2198e458d41537eec08142e5faae9f56c0fee832d1f34e88e1f7481a9b5d11257b779719b2b4f37c41be73900277a64c7bcaab11c67df1ae1b

data/CREDITS

@@ -10,3 +10,4 @@
 * Keita Urashima <ursm@ursm.jp>
 * Pius Uzamere <pius@alum.mit.edu>
 * Judson Lester <nyarly@gmail.com>
+* Peter Vandenabeele <peter@vandenabeele.com>

data/VERSION

@@ -1 +1 @@
-1.1.3
+1.1.4

data/lib/rdf.rb

@@ -193,61 +193,23 @@ module RDF
   # @return [#to_s] property
   # @return [URI]
   def self.[](property)
-    RDF::URI.intern([to_uri.to_s, property.to_s].join)
+    property.to_s =~ %r{_\d+} ? RDF::URI("#{to_uri}#{property}") : RDF::RDFV[property]
   end
 
   ##
-  # @param  [Symbol] property
-  # @return [URI]
-  # @raise  [NoMethodError]
+  # respond to module or RDFV
+  def self.respond_to?(method)
+    super || RDF::RDFV.respond_to?(method)
+  end
+
+  ##
+  # Delegate other methods to RDF::RDF
   def self.method_missing(property, *args, &block)
     if args.empty?
-      self[property]
+      # Special-case rdf:_n for all integers
+      property.to_s =~ %r{_\d+} ? RDF::URI("#{to_uri}#{property}") : RDF::RDFV.send(property)
     else
       super
     end
   end
-
-  ##
-  # @return [URI]
-  def self.to_rdf
-    to_uri
-  end
-
-  ##
-  # @return [URI]
-  def self.to_uri
-    RDF::URI.intern("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
-  end
-
-  # RDF Vocabulary terms
-  %w(
-    Alt
-    Bag
-    first
-    HTML
-    langString
-    nil
-    object
-    predicate
-    Property
-    rest
-    Seq
-    subject
-    type
-    value
-    XMLLiteral
-  ).each do |term|
-    term_uri = self[term.to_sym]
-    define_method(term) {term_uri}
-    module_function term.to_sym
-  end
-
-  class << self
-    # For compatibility with `RDF::Vocabulary.__name__`:
-    alias_method :__name__, :name
-    
-    # For IRI compatibility
-    alias_method :to_iri, :to_uri
-  end
 end

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

@@ -9,27 +9,27 @@ module RDF
   class VocabularyLoader
     def initialize(class_name = nil)
       @class_name = class_name
+      @module_name = "RDF"
       @output = $stdout
       @output_class_file = true
-      @prefix = nil
-      @url = nil
+      @uri = nil
       @strict = true
       @extra = []
     end
-    attr_accessor :class_name, :output, :output_class_file
-    attr_reader :prefix, :source
+    attr_accessor :class_name, :module_name, :output, :output_class_file
+    attr_reader :uri, :source
 
-    # Set the prefix for the loaded RDF file - by default, sets the source as
+    # Set the URI for the loaded RDF file - by default, sets the source as
     # well
-    def prefix=(uri)
-      @prefix = uri
+    def uri=(uri)
+      @uri = uri
       @source ||= uri
     end
 
-    # Set the source for the loaded RDF - by default, sets the prefix as well
+    # Set the source for the loaded RDF - by default, sets the URI as well
     def source=(uri)
       @source = uri
-      @prefix ||= uri
+      @uri ||= uri
     end
 
     # Set output
@@ -50,10 +50,10 @@ module RDF
     # 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.banner = "Usage: #{File.basename($0)} [options] [uri]\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
+      opti.on("--uri URI", "The URI for the fetched RDF vocabulary") do |uri|
+        self.uri = uri
       end
 
       opti.on("--source SOURCE", "The source URI or file for the vocabulary") do |uri|
@@ -64,6 +64,10 @@ module RDF
         self.class_name = name
       end
 
+      opti.on("--module-name NAME", "The module name for the output StrictVocabulary subclass") do |name|
+        self.module_name = name
+      end
+
       opti.on("--raw", "Don't output an output file - just the RDF") do
         @output_class_file = false
       end
@@ -79,26 +83,7 @@ module RDF
         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)
+      uri ||= others.first
     end
 
     # Parse command line arguments and run the load-and-emit process
@@ -111,126 +96,77 @@ module RDF
       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
+    ##
+    # Turn a node definition into a property/term expression
+    def from_node(name, attributes, term_type)
+      op = term_type == :property ? "property" : "term"
+
+      components = ["    #{op} #{name.to_sym.inspect}"]
+      attributes.keys.sort_by(&:to_s).each do |key|
+        next if key == :vocab
+        value = Array(attributes[key])
+        component = key.is_a?(Symbol) ? "#{key}: " : "#{key.inspect} => "
+        value = value.first if value.length == 1
+        component << if value.is_a?(Array)
+          '[' + value.map {|v| serialize_value(v, key)}.join(", ") + "]"
+        else
+          serialize_value(value, key)
+        end
+        components << component
+      end
+      @output.puts components.join(",\n      ")
+    end
+
+    def serialize_value(value, key)
+      case key
+      when :comment, String
+        "%(#{value.gsub('(', '\(').gsub(')', '\)')}).freeze"
+      else
+        "#{value.inspect}.freeze"
+      end
     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}
+      @output.print %(# -*- encoding: utf-8 -*-
+        # This file generated automatically using vocab-fetch from #{source}
         require 'rdf'
-        module RDF
-          class #{class_name} < #{"Strict" if @strict}Vocabulary("#{prefix}")
+        module #{module_name}
+          class #{class_name} < RDF::#{"Strict" if @strict}Vocabulary("#{uri}")
         ).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}"
+      # Extract statements with subjects that have the vocabulary prefix and organize into a hash of properties and values
+      vocab = RDF::Vocabulary.load(uri, location: source, extra: @extra)
+
+      # Split nodes into Class/Property/Datatype/Other
+      term_nodes = {
+        class: {},
+        property: {},
+        datatype: {},
+        other: {}
+      }
+      vocab.each.to_a.sort.each do |term|
+        name = term.to_s[uri.length..-1].to_sym
+        kind = case term.type.to_s
+        when /Class/    then :class
+        when /Property/ then :property
+        when /Datatype/ then :datatype
+        else                 :other
         end
+        term_nodes[kind][name] = term.attributes
+      end
+
+      {
+        class: "Class definitions",
+        property: "Property definitions",
+        datatype: "Datatype definitions",
+        other: "Extra definitions"
+      }.each do |tt, comment|
+        next if term_nodes[tt].empty?
+        @output.puts "\n    # #{comment}"
+        term_nodes[tt].each {|name, attributes| from_node name, attributes, tt}
       end
 
       # Query the vocabulary to extract property and class definitions

data/lib/rdf/mixin/enumerable.rb

@@ -693,5 +693,30 @@ module RDF
         super
       end
     end
+
+    ##
+    # @private
+    # @param  [Symbol, #to_sym] method
+    # @return [Enumerator]
+    # @see    Object#enum_for
+    def enum_for(method = :each, *args)
+      # Ensure that enumerators are, themselves, queryable
+      this = self
+      Enumerable::Enumerator.new do |yielder|
+        this.send(method, *args) {|*y| yielder << (y.length > 1 ? y : y.first)}
+      end
+    end
+    alias_method :to_enum, :enum_for
+
+    # Extends Enumerator with {Queryable} and {Enumerable}, which is used by {Enumerable#each_statement} and {Queryable#enum_for}
+    class Enumerator < ::Enumerator
+      include Queryable
+      include Enumerable
+
+      # Make sure returned arrays are also queryable
+      def to_a
+        return super.to_a.extend(RDF::Queryable, RDF::Enumerable)
+      end
+    end
   end # Enumerable
 end # RDF

data/lib/rdf/mixin/mutable.rb

@@ -33,6 +33,9 @@ module RDF
     #
     # @param  [String, #to_s]          filename
     # @param  [Hash{Symbol => Object}] options
+    #   Options from {RDF::Reader.open}
+    # @option options [RDF::Resource] :context
+    #   Set set context of each loaded statement
     # @return [void]
     def load(filename, options = {})
       raise TypeError.new("#{self} is immutable") if immutable?

data/lib/rdf/model/graph.rb

@@ -71,7 +71,7 @@ module RDF
     #
     # @param  [String, #to_s]          url
     # @param  [Hash{Symbol => Object}] options
-    #   Options from {RDF::Reader#initialize}, {RDF::Format.for} and {RDF::Graph#initialize}
+    #   Options from {RDF::Graph#initialize} and {RDF::Mutable#load}
     # @yield  [graph]
     # @yieldparam [Graph] graph
     # @return [Graph]

data/lib/rdf/model/node.rb

@@ -12,6 +12,21 @@ module RDF
   class Node
     include RDF::Resource
 
+    ##
+    # Defines the maximum number of interned Node references that can be held
+    # cached in memory at any one time.
+    #
+    # Note that caching interned nodes means that two different invocations using the same symbol will result in the same node, which may not be appropriate depending on the context from which it is used. RDF requires that bnodes with the same label are, in fact, different bnodes, unless they are used wihin the same document.
+    CACHE_SIZE = -1 # unlimited by default
+
+    ##
+    # @return [RDF::Util::Cache]
+    # @private
+    def self.cache
+      require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
+      @cache ||= RDF::Util::Cache.new(CACHE_SIZE)
+    end
+
     ##
     # Returns a blank node with a random UUID-based identifier.
     #
@@ -41,7 +56,7 @@ module RDF
     # @return [RDF::Node]
     # @since  0.2.0
     def self.intern(id)
-      self.new(id)
+      (cache[id = id.to_s] ||= self.new(id)).freeze
     end
 
     ##
@@ -140,13 +155,21 @@ module RDF
     alias_method :===, :==
 
     ##
-    # Returns the base representation of this URI.
+    # Returns the base representation of this node.
     #
     # @return [Sring]
     def to_base
       to_s
     end
 
+    ##
+    # Returns a representation of this node independent of any identifier used to initialize it
+    #
+    # @return [String]
+    def to_unique_base
+      "_:g#{__id__.to_i.abs}"
+    end
+
     ##
     # Returns a string representation of this blank node.
     #