rdf 1.1.0p4 → 1.1.0

data/lib/rdf/query/solutions.rb

@@ -60,6 +60,35 @@ module RDF; class Query
       super
     end
 
+    ##
+    # Returns an array of the distinct variable names used in this solution
+    # sequence.
+    #
+    # @return [Array<Symbol>]
+    def variable_names
+      variables = self.inject({}) do |result, solution|
+        solution.each_name do |name|
+          result[name] ||= true
+        end
+        result
+      end
+      variables.keys
+    end
+
+    ##
+    # Returns `true` if this solution sequence contains bindings for any of
+    # the given `variables`.
+    #
+    # @param  [Array<Symbol, #to_sym>] variables
+    #   an array of variables to check
+    # @return [Boolean] `true` or `false`
+    # @see    RDF::Query::Solution#has_variables?
+    # @see    RDF::Query#execute
+    def have_variables?(variables)
+      self.any? { |solution| solution.has_variables?(variables) }
+    end
+    alias_method :has_variables?, :have_variables?
+
     ##
     # Returns hash of bindings from each solution. Each bound variable will have
     # an array of bound values representing those from each solution, where a given
@@ -222,34 +251,5 @@ module RDF; class Query
       self
     end
     alias_method :limit!, :limit
-
-    ##
-    # Returns an array of the distinct variable names used in this solution
-    # sequence.
-    #
-    # @return [Array<Symbol>]
-    def variable_names
-      variables = self.inject({}) do |result, solution|
-        solution.each_name do |name|
-          result[name] ||= true
-        end
-        result
-      end
-      variables.keys
-    end
-
-    ##
-    # Returns `true` if this solution sequence contains bindings for any of
-    # the given `variables`.
-    #
-    # @param  [Array<Symbol, #to_sym>] variables
-    #   an array of variables to check
-    # @return [Boolean] `true` or `false`
-    # @see    RDF::Query::Solution#has_variables?
-    # @see    RDF::Query#execute
-    def have_variables?(variables)
-      self.any? { |solution| solution.has_variables?(variables) }
-    end
-    alias_method :has_variables?, :have_variables?
   end # Solutions
 end; end # RDF::Query

data/lib/rdf/reader.rb

@@ -217,10 +217,10 @@ module RDF
     # @example
     #   reader.prefixes[:dc]  #=> RDF::URI('http://purl.org/dc/terms/')
     #
-    # @return [Hash{Symbol => RDF::URI}]
+    # @return [RDF::URI]
     # @since  0.3.0
     def base_uri
-      @options[:base_uri]
+      RDF::URI(@options[:base_uri]) if @options[:base_uri]
     end
 
     ##
@@ -486,7 +486,17 @@ module RDF
       @line = @line_rest || @input.readline
       @line, @line_rest = @line.split("\r", 2)
       @line = @line.to_s.chomp
-      @line.encode!(encoding)
+      begin
+        @line.encode!(encoding)
+      rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError, Encoding::ConverterNotFoundError
+        # It is likely the persisted line was not encoded on initial write
+        # (i.e. persisted via RDF <= 1.0.9 and read via RDF >= 1.0.10)
+        #
+        # Encoding::UndefinedConversionError is raised by MRI.
+        # Encoding::InvalidByteSequenceError is raised by jruby >= 1.7.5
+        # Encoding::ConverterNotFoundError is raised by jruby < 1.7.5
+        @line = RDF::NTriples::Reader.unescape(@line).encode(encoding)
+      end
       @line
     end
 

data/lib/rdf/repository.rb

@@ -232,6 +232,7 @@ module RDF
           # statement contexts / named graphs
           when :context   then @options[:with_context]
           when :inference then false  # forward-chaining inference
+          when :validity  then @options.fetch(:with_validity, true)
           else false
         end
       end

data/lib/rdf/util/file.rb

@@ -1,3 +1,6 @@
+require 'net/http'
+require 'time'
+
 module RDF; module Util
   ##
   # Wrapper for Kernel.open. Allows implementations to override to get
@@ -23,6 +26,8 @@ module RDF; module Util
     # Adds Accept header based on available reader content types to allow
     # for content negotiation based on available readers.
     #
+    # When retrieving documents over HTTP(S), use the mechanism described in [Providing and Discovering URI Documentation](http://www.w3.org/2001/tag/awwsw/issue57/latest/) to pass the appropriate `base_uri` to the block or as the return.
+    #
     # @param [String] filename_or_url to open
     # @param  [Hash{Symbol => Object}] options
     #   options are ignored in this implementation. Applications are encouraged
@@ -31,19 +36,94 @@ module RDF; module Util
     #   options are passed to `Kernel.open`.
     # @option options [Array, String] :headers
     #   HTTP Request headers, passed to Kernel.open.
-    # @return [IO] File stream
-    # @yield [IO] File stream
+    # @return [IO, Reader] File stream with no block, and the block return otherwise
+    # @yield [IO, StringIO] File stream
     def self.open_file(filename_or_url, options = {}, &block)
       filename_or_url = $1 if filename_or_url.to_s.match(/^file:(.*)$/)
-      if filename_or_url.to_s =~ /^#{RDF::URI::SCHEME}/
-        # Open as a URL
+      if filename_or_url.to_s =~ /^https?/
+        # Open as a URL with Net::HTTP
         headers = options.fetch(:headers, {})
-        headers['Accept'] ||= (RDF::Format.reader_types + %w(*/*;q=0.1)).join(", ")
-        Kernel.open(filename_or_url.to_s, headers, &block)
+        # Receive text/html and text/plain at a lower priority than other formats
+        reader_types = RDF::Format.reader_types.map do |t|
+          t.to_s =~ /text\/(?:plain|html)/  ? "#{t};q=0.5" : t
+        end
+        headers['Accept'] ||= (reader_types + %w(*/*;q=0.1)).join(", ")
+
+        redirect_count = 0
+        max_redirects = 5
+        remote_document = nil
+        parsed_url = ::URI.parse(filename_or_url.to_s)
+        base_uri = parsed_url.to_s
+        result = nil
+        until remote_document do
+          Net::HTTP::start(parsed_url.host, parsed_url.port,
+                          :open_timeout => 60 * 1000,
+                          :use_ssl => filename_or_url.start_with?("https")
+          ) do |http|
+            request = Net::HTTP::Get.new(parsed_url.request_uri, headers)
+            http.request(request) do |response|
+              case response
+              when Net::HTTPSuccess
+                # found object
+
+                # If a Location is returned, it defines the base resource for this file, not it's actual ending location
+
+                document_options = {
+                  :content_type => response.content_type,
+                  :charset => "utf-8",
+                  :base_uri => RDF::URI(response["Location"] ? response["Location"] : base_uri)
+                }.merge(response.type_params)
+                document_options[:last_modified] = DateTime.parse(response["Last-Modified"]) if response["Last-Modified"]
+
+                remote_document = RemoteDocument.new(response.body, document_options)
+
+                # Yield the result and close, or cause it to be returned
+                result = if block_given?
+                  ret = yield remote_document
+                  remote_document.close
+                  ret
+                else
+                  remote_document
+                end
+              when Net::HTTPRedirection
+                # Follow redirection
+                raise IOError, "Too many redirects" if (redirect_count += 1) > max_redirects
+
+                parsed_url = ::URI.parse(response["Location"])
+
+                # If response is not a status 303, update base_uri too
+                base_uri = parsed_url.to_s unless response.code == "303"
+              else
+                raise IOError, "<#{parsed_url}>: #{response.msg}(#{response.code})"
+              end
+            end
+          end
+        end
+        result
       else
         # Open as a file, passing any options
         Kernel.open(filename_or_url, "r", options, &block)
       end
     end
+
+    class RemoteDocument < StringIO
+      attr_reader :base_uri
+      attr_reader :content_type
+      attr_reader :charset
+      attr_reader :content_encoding
+      attr_reader :last_modified
+
+      ##
+      # Set content
+      def initialize(body, options = {})
+        super(body)
+        options.each do |key, value|
+          # de-quote charset
+          value = $1 if key == "charset" && value =~ /^["'](.*)["']$/
+          instance_variable_set(:"@#{key}", value)
+        end
+        set_encoding Encoding.find(@charset) if @charset
+      end
+    end
   end # File
 end; end # RDF::Util

data/lib/rdf/vocab.rb

@@ -15,16 +15,27 @@ module RDF
   # * {RDF::EXIF}   - Exchangeable Image File Format (EXIF)
   # * {RDF::FOAF}   - Friend of a Friend (FOAF)
   # * {RDF::GEO}    - WGS84 Geo Positioning (GEO)
+  # * {RDF::GR}     - Good Relations
   # * {RDF::HTTP}   - Hypertext Transfer Protocol (HTTP)
+  # * {RDF::ICAL}   - iCal
+  # * {RDF::MA}     - W3C Meda Annotations
+  # * {RDF::OG}     - FaceBook OpenGraph
   # * {RDF::OWL}    - Web Ontology Language (OWL)
+  # * {RDF::PROV}   - W3C Provenance Ontology
   # * {RDF::RDFS}   - RDF Schema (RDFS)
   # * {RDF::RSA}    - W3 RSA Keys (RSA)
   # * {RDF::RSS}    - RDF Site Summary (RSS)
   # * {RDF::SCHEMA} - Schema.org
   # * {RDF::SIOC}   - Semantically-Interlinked Online Communities (SIOC)
   # * {RDF::SKOS}   - Simple Knowledge Organization System (SKOS)
+  # * {RDF::SKOSXL} - SKOS Simple Knowledge Organization System eXtension for Labels (SKOS-XL)
+  # * {RDF::V}      - Data Vocabulary
+  # * {RDF::VCARD}  - vCard vocabulary
+  # * {RDF::VOID}   - Vocabulary of Interlinked Datasets (VoID)
+  # * {RDF::WDRS}   - Protocol for Web Description Resources (POWDER)
   # * {RDF::WOT}    - Web of Trust (WOT)
   # * {RDF::XHTML}  - Extensible HyperText Markup Language (XHTML)
+  # * {RDF::XHV}    - W3C XHTML Vocabulary
   # * {RDF::XSD}    - XML Schema (XSD)
   #
   # @example Using pre-defined RDF vocabularies
@@ -49,72 +60,99 @@ module RDF
   class Vocabulary
     extend ::Enumerable
 
-    ##
-    # Enumerates known RDF vocabulary classes.
-    #
-    # @yield  [klass]
-    # @yieldparam [Class] klass
-    # @return [Enumerator]
-    def self.each(&block)
-      if self.equal?(Vocabulary)
-        # This is needed since all vocabulary classes are defined using
-        # Ruby's autoloading facility, meaning that `@@subclasses` will be
-        # empty until each subclass has been touched or require'd.
-        RDF::VOCABS.each { |v| require "rdf/vocab/#{v}" unless v == :rdf }
-        @@subclasses.each(&block)
-      else
-        # TODO: should enumerate vocabulary-specific defined properties.
+    class << self
+      ##
+      # Enumerates known RDF vocabulary classes.
+      #
+      # @yield  [klass]
+      # @yieldparam [Class] klass
+      # @return [Enumerator]
+      def each(&block)
+        if self.equal?(Vocabulary)
+          # This is needed since all vocabulary classes are defined using
+          # Ruby's autoloading facility, meaning that `@@subclasses` will be
+          # empty until each subclass has been touched or require'd.
+          RDF::VOCABS.each { |v| require "rdf/vocab/#{v}" unless v == :rdf }
+          @@subclasses.each(&block)
+        else
+          # TODO: should enumerate vocabulary-specific defined properties.
+        end
       end
-    end
 
-    ##
-    # Defines a vocabulary term called `property`.
-    #
-    # @param  [Symbol] property
-    # @return [void]
-    def self.property(property)
-      metaclass = class << self; self; end
-      metaclass.send(:define_method, property) { self[property] } # class method
-    end
+      ##
+      # @overload property
+      #   Returns `property` in the current vocabulary
+      #   @return [RDF::URI]
+      #
+      # @overload property(name, options)
+      #   Defines a new property or class in the vocabulary.
+      #   Optional labels and comments are stripped of unnecessary whitespace.
+      # 
+      #   @param [String, #to_s] name
+      #   @param [Hash{Symbol => Object}] options
+      #   @option options [String, #to_s] :label
+      #   @option options [String, #to_s] :comment
+      def property(*args)
+        case args.length
+        when 0
+          RDF::URI.intern("#{self}property")
+        else
+          name, options = args
+          options ||= {}
+          prop = RDF::URI.intern([to_s, name.to_s].join(''))
+          @@labels[prop] = options[:label].to_s.strip.gsub(/\s+/m, ' ') if options[:label]
+          @@comments[prop] = options[:comment].to_s.strip.gsub(/\s+/m, ' ') if options[:comment]
+          (class << self; self; end).send(:define_method, name) { prop } unless name.to_s == "property"
+        end
+      end
 
-    ##
-    # Returns the URI for the term `property` in this vocabulary.
-    #
-    # @param  [#to_s] property
-    # @return [RDF::URI]
-    def self.[](property)
-      RDF::URI.intern([to_s, property.to_s].join(''))
-    end
+      ##
+      # Returns the URI for the term `property` in this vocabulary.
+      #
+      # @param  [#to_s] property
+      # @return [RDF::URI]
+      def [](property)
+        RDF::URI.intern([to_s, property.to_s].join(''))
+      end
 
-    ##
-    # Returns the base URI for this vocabulary class.
-    #
-    # @return [RDF::URI]
-    def self.to_uri
-      RDF::URI.intern(to_s)
-    end
+      # @return [String] The label for the named property
+      def label_for(name)
+        @@labels[self[name]]
+      end
 
-    ##
-    # Returns a string representation of this vocabulary class.
-    #
-    # @return [String]
-    def self.to_s
-      @@uris.has_key?(self) ? @@uris[self].to_s : super
-    end
+      # @return [String] The comment for the named property
+      def comment_for(name)
+        @@comments[self[name]]
+      end
 
-    ##
-    # Returns a developer-friendly representation of this vocabulary class.
-    #
-    # @return [String]
-    def self.inspect
-      if self == Vocabulary
-        self.to_s
-      else
-        sprintf("%s(%s)", superclass.to_s, to_s)
+      ##
+      # Returns the base URI for this vocabulary class.
+      #
+      # @return [RDF::URI]
+      def to_uri
+        RDF::URI.intern(to_s)
+      end
+
+      ##
+      # Returns a string representation of this vocabulary class.
+      #
+      # @return [String]
+      def to_s
+        @@uris.has_key?(self) ? @@uris[self].to_s : super
+      end
+
+      ##
+      # Returns a developer-friendly representation of this vocabulary class.
+      #
+      # @return [String]
+      def inspect
+        if self == Vocabulary
+          self.to_s
+        else
+          sprintf("%s(%s)", superclass.to_s, to_s)
+        end
       end
-    end
 
-    class << self
       # Preserve the class name so that it can be obtained even for
       # vocabularies that define a `name` property:
       alias_method :__name__, :name
@@ -216,5 +254,67 @@ module RDF
     @@subclasses = [::RDF] # @private
     @@uris       = {}      # @private
     @@uri        = nil     # @private
+    @@labels     = {}
+    @@comments   = {}
   end # Vocabulary
+
+  # Represents an RDF Vocabulary. The difference from {RDF::Vocabulary} is that
+  # that every concept in the vocabulary is required to be declared. To assist
+  # in this, an existing RDF representation of the vocabulary can be loaded as
+  # the basis for concepts being available
+  class StrictVocabulary < Vocabulary
+    class << self
+      begin
+        # Redefines method_missing to the original definition
+        # By remaining a subclass of Vocabulary, we remain available to
+        # Vocabulary::each etc.
+        define_method(:method_missing, BasicObject.instance_method(:method_missing))
+      rescue NameError
+        define_method(:method_missing, Kernel.instance_method(:method_missing))
+      end
+
+      ##
+      # @overload property
+      #   Returns `property` in the current vocabulary
+      #   @return [RDF::URI]
+      #
+      # @overload property(name, options)
+      #   Defines a new property or class in the vocabulary.
+      #   Optional labels and comments are stripped of unnecessary whitespace.
+      # 
+      #   @param [String, #to_s] name
+      #   @param [Hash{Symbol => Object}] options
+      #   @option options [String, #to_s] :label
+      #   @option options [String, #to_s] :comment
+      def property(*args)
+        case args.length
+        when 0
+          RDF::URI.intern("#{self}property")
+        else
+          name, options = args
+          options ||= {}
+          prop = RDF::URI.intern([to_s, name.to_s].join(''))
+          @@properties[prop] = true
+          @@labels[prop] = options[:label].to_s.strip.gsub(/\s+/m, ' ') if options[:label]
+          @@comments[prop] = options[:comment].to_s.strip.gsub(/\s+/m, ' ') if options[:comment]
+          (class << self; self; end).send(:define_method, name) { prop } unless name.to_s == "property"
+        end
+      end
+
+      def [](name)
+        prop = RDF::URI.intern([to_s, name.to_s].join(''))
+        @@properties.fetch(prop) #raises KeyError on missing value
+        return prop
+      end
+    end
+
+    begin
+      define_method(:method_missing, BasicObject.instance_method(:method_missing))
+    rescue NameError
+      define_method(:method_missing, Kernel.instance_method(:method_missing))
+    end
+
+    private
+    @@properties = {}
+  end # StrictVocabulary
 end # RDF