rdf 0.3.3 → 0.3.4

data/lib/rdf/format.rb

@@ -19,7 +19,7 @@ module RDF
   #   RDF::Format.content_types      #=> {"text/plain" => [RDF::NTriples::Format]}
   #
   # @example Obtaining serialization format file extension mappings
-  #   RDF::Format.file_extensions    #=> {:nt => "text/plain"}
+  #   RDF::Format.file_extensions    #=> {:nt => [RDF::NTriples::Format]}
   #
   # @example Defining a new RDF serialization format class
   #   class RDF::NTriples::Format < RDF::Format
@@ -77,11 +77,18 @@ module RDF
     #   @option options [String, #to_s]   :file_name      (nil)
     #   @option options [Symbol, #to_sym] :file_extension (nil)
     #   @option options [String, #to_s]   :content_type   (nil)
+    #     Note that content_type will be taken from a URL opened using {RDF::Util::File.open_file}.
+    #   @option options [String]          :sample (nil)
+    #     A sample of input used for performing format detection.
+    #     If we find no formats, or we find more than one, and we have a sample, we can
+    #     perform format detection to find a specific format to use, in which case
+    #     we pick the first one we find
     #   @return [Class]
+    #   @yieldreturn [String] another way to provide a sample, allows lazy for retrieving the sample.
     #
     # @return [Class]
     def self.for(options = {})
-      case options
+      format = case options
         when String
           # Find a format based on the file name
           self.for(:file_name => options)
@@ -94,15 +101,13 @@ module RDF
               # @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
               mime_type = mime_type.to_s
               mime_type = mime_type.split(';').first if mime_type.include?(?;) # remove any media type parameters
-              content_types.has_key?(mime_type) ? content_types[mime_type].first : nil
+              content_types[mime_type]
             # 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])
             # Find a format based on the file extension:
             when file_ext  = options[:file_extension]
-              if file_extensions.has_key?(file_ext = file_ext.to_sym)
-                self.for(:content_type => file_extensions[file_ext])
-              end
+              file_extensions[file_ext.to_sym]
           end
 
         when Symbol
@@ -112,15 +117,31 @@ module RDF
               RDF::NTriples::Format
             # For anything else, find a match based on the full class name
             else
-              format = format.to_s.downcase
               @@subclasses.each do |klass|
-                if klass.name.to_s.split('::').map(&:downcase).include?(format)
+                if klass.to_sym == format ||
+                   klass.name.to_s.split('::').map(&:downcase).include?(format.to_s.downcase)
                   return klass
                 end
               end
               nil # not found
           end
       end
+      
+      if format.is_a?(Array)
+        return format.first if format.uniq.length == 1
+      elsif !format.nil?
+        return format
+      end
+
+      # If we have a sample, use that for format detection
+      if sample = (options[:sample] if options.is_a?(Hash)) || (yield if block_given?)
+        # Given a sample, perform format detection across the appropriate formats, choosing
+        # the first that matches
+        format ||= @@subclasses
+
+        # Return first format that has a positive detection
+        format.detect {|f| f.detect(sample)}
+      end
     end
 
     ##
@@ -134,11 +155,21 @@ module RDF
     ##
     # Returns file extensions for known RDF serialization formats.
     #
-    # @return [Hash{Symbol => String}]
+    # @return [Hash{Symbol => Array<Class>}]
     def self.file_extensions
       @@file_extensions
     end
 
+    ##
+    # Returns a symbol appropriate to use with RDF::Format.for()
+    # @return [Symbol]
+    def self.to_sym
+      elements = self.to_s.split("::")
+      sym = elements.pop
+      sym = elements.pop if sym == 'Format'
+      sym.downcase.to_s.to_sym
+    end
+
     ##
     # Retrieves or defines the reader class for this RDF serialization
     # format.
@@ -225,6 +256,24 @@ module RDF
       end
     end
 
+
+    ##
+    # Use a text sample to detect the format of an input file. Sub-classes implement
+    # a matcher sufficient to detect probably format matches, including disambiguating
+    # between other similar formats.
+    #
+    # Used to determine format class from loaded formats by {RDF::Format.for} when a
+    # match cannot be unambigiously found otherwise.
+    #
+    # @example
+    #     RDF::NTriples::Format.detect("<a> <b> <c> .") => true
+    #
+    # @param [String] sample Beginning several bytes (~ 1K) of input.
+    # @return [Boolean]
+    def self.detect(sample)
+      false
+    end
+
     class << self
       alias_method :reader_class, :reader
       alias_method :writer_class, :writer
@@ -267,7 +316,7 @@ module RDF
 
         if extensions = (options[:extension] || options[:extensions])
           extensions = [extensions].flatten.map(&:to_sym)
-          extensions.each { |ext| @@file_extensions[ext] = type }
+          extensions.each { |ext| (@@file_extensions[ext] ||= []) << self }
         end
         if aliases = (options[:alias] || options[:aliases])
           aliases = [aliases].flatten.each { |a| (@@content_types[a] ||= []) << self }

data/lib/rdf/mixin/type_check.rb

@@ -0,0 +1,21 @@
+module RDF
+  ##
+  # An RDF type check mixin.
+  #
+  # This module implements #raise_error, which will raise RDF::TypeError.
+  #
+  # @see RDF::Value
+  # @see RDF::Literal
+  # @see RDF::Literal
+  module TypeCheck
+    ##
+    # Default implementation of type_error, which returns false.
+    # Classes including RDF::TypeCheck will raise TypeError
+    # instead.
+    #
+    # @raise [TypeError]
+    def type_error(message)
+      raise TypeError, message
+    end
+  end # TypeCheck
+end # RDF

data/lib/rdf/model/graph.rb

@@ -47,6 +47,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}
     # @yield  [graph]
     # @yieldparam [Graph] graph
     # @return [Graph]

data/lib/rdf/model/list.rb

@@ -56,17 +56,50 @@ module RDF
     # The canonical empty list.
     NIL = RDF::List.new(RDF.nil).freeze
 
+    ##
+    # Validate the list ensuring that
+    # * rdf:rest values are all BNodes are nil
+    # * rdf:type, if it exists, is rdf:List
+    # * each subject has no properties other than single-valued rdf:first, rdf:rest
+    #   other than for the first node in the list
+    # @return [Boolean]
+    def valid?
+      li = subject
+      while li != RDF.nil do
+        rest = nil
+        firsts = rests = 0
+        @graph.query(:subject => li) do |st|
+          case st.predicate
+          when RDF.type
+            # Be tollerant about rdf:type entries, as some OWL vocabularies use it excessively
+          when RDF.first
+            firsts += 1
+          when RDF.rest
+            rest = st.object
+            return false unless rest.node? || rest == RDF.nil
+            rests += 1
+          else
+            # First node may have other properties
+            return false unless li == subject
+          end
+        end
+        return false unless firsts == 1 && rests == 1
+        li = rest
+      end
+      true
+    end
+
     ##
     # Returns the subject term of this list.
     #
-    # @return [RDF::Resource]
+    # @attr_reader [RDF::Resource]
     attr_reader :subject
 
     ##
     # Returns the underlying graph storing the statements that constitute
     # this list.
     #
-    # @return [RDF::Graph]
+    # @attr_reader [RDF::Graph]
     attr_reader :graph
 
     ##
@@ -489,7 +522,7 @@ module RDF
     ##
     # Returns the first subject term constituting this list.
     #
-    # This is equivalent to {#subject}.
+    # This is equivalent to `subject`.
     #
     # @example
     #   RDF::List[1, 2, 3].first_subject        #=> RDF::Node(...)

data/lib/rdf/model/literal.rb

@@ -2,9 +2,30 @@ module RDF
   ##
   # An RDF literal.
   #
+  # Subclasses of {RDF::Literal} should define DATATYPE and GRAMMAR constants, which are used
+  # for identifying the appropriate class to use for a datatype URI and to perform lexical
+  # matching on the value.
+  #
+  # Literal comparison with other {RDF::Value} instances call {RDF::Value#type_error},
+  # which, returns false. Implementations wishing to have {RDF::TypeError} raised
+  # should mix-in {RDF::TypeCheck}. This is required for strict SPARQL conformance.
+  #
+  # Specific typed literals may have behavior different from the default implementation. See
+  # the following defined sub-classes for specific documentation. Additional sub-classes may
+  # be defined, and will interoperate by defining `DATATYPE` and `GRAMMAR` constants, in addition
+  # other required overrides of RDF::Literal behavior.
+  #
+  # * {RDF::Literal::Boolean}
+  # * {RDF::Literal::Date}
+  # * {RDF::Literal::DateTime}
+  # * {RDF::Literal::Decimal}
+  # * {RDF::Literal::Double}
+  # * {RDF::Literal::Integer}
+  # * {RDF::Literal::Time}
+  #
   # @example Creating a plain literal
   #   value = RDF::Literal.new("Hello, world!")
-  #   value.plain?                                   #=> true
+  #   value.plain?                                   #=> true`
   #
   # @example Creating a language-tagged literal (1)
   #   value = RDF::Literal.new("Hello!", :language => :en)
@@ -39,53 +60,48 @@ module RDF
   # @see http://www.w3.org/TR/rdf-concepts/#section-Literals
   # @see http://www.w3.org/TR/rdf-concepts/#section-Datatypes-intro
   class Literal
-    autoload :Boolean,  'rdf/model/literal/boolean'
-    autoload :Numeric,  'rdf/model/literal/numeric'
-    autoload :Integer,  'rdf/model/literal/integer'
-    autoload :Double,   'rdf/model/literal/double'
-    autoload :Decimal,  'rdf/model/literal/decimal'
-    autoload :Date,     'rdf/model/literal/date'
-    autoload :DateTime, 'rdf/model/literal/datetime'
-    autoload :Time,     'rdf/model/literal/time'
-    autoload :Token,    'rdf/model/literal/token'
-    autoload :XML,      'rdf/model/literal/xml'
+
+  private
+    @@subclasses       = [] # @private
+
+    ##
+    # @private
+    # @return [void]
+    def self.inherited(child)
+      @@subclasses << child
+      super
+    end
+  
+  public
+
+    require 'rdf/model/literal/numeric'
+    require 'rdf/model/literal/boolean'
+    require 'rdf/model/literal/decimal'
+    require 'rdf/model/literal/integer'
+    require 'rdf/model/literal/double'
+    require 'rdf/model/literal/date'
+    require 'rdf/model/literal/dateTime'
+    require 'rdf/model/literal/time'
+    require 'rdf/model/literal/token'
+    require 'rdf/model/literal/xml'
 
     include RDF::Term
 
+    ##
+    # @private
+    # Return datatype class for uri, or nil if none is found
+    def self.datatyped_class(uri)
+      @@subclasses.detect {|klass| klass.const_defined?(:DATATYPE) && klass.const_get(:DATATYPE) == uri}
+    end
+
     ##
     # @private
     def self.new(value, options = {})
       klass = case
         when !self.equal?(RDF::Literal)
           self # subclasses can be directly constructed without type dispatch
-        when datatype = options[:datatype]
-          case RDF::URI(datatype)
-            when XSD.boolean
-              RDF::Literal::Boolean
-            when XSD.integer, XSD.long, XSD.int, XSD.short, XSD.byte
-              RDF::Literal::Integer
-            when XSD.double, XSD.float
-              RDF::Literal::Double
-            when XSD.decimal
-              RDF::Literal::Decimal
-            when XSD.date
-              RDF::Literal::Date
-            when XSD.dateTime
-              RDF::Literal::DateTime
-            when XSD.time
-              RDF::Literal::Time
-            when XSD.nonPositiveInteger, XSD.negativeInteger
-              RDF::Literal::Integer
-            when XSD.nonNegativeInteger, XSD.positiveInteger
-              RDF::Literal::Integer
-            when XSD.unsignedLong, XSD.unsignedInt, XSD.unsignedShort, XSD.unsignedByte
-              RDF::Literal::Integer
-            when XSD.token, XSD.language
-              RDF::Literal::Token
-            when RDF.XMLLiteral
-              RDF::Literal::XML
-            else self
-          end
+        when typed_literal = datatyped_class(RDF::URI(options[:datatype]))
+          typed_literal
         else case value
           when ::TrueClass  then RDF::Literal::Boolean
           when ::FalseClass then RDF::Literal::Boolean
@@ -123,8 +139,10 @@ module RDF
     def initialize(value, options = {})
       @object   = value
       @string   = options[:lexical] if options[:lexical]
+      @string   = value if !defined?(@string) && value.is_a?(String)
       @language = options[:language].to_s.to_sym if options[:language]
       @datatype = RDF::URI(options[:datatype]) if options[:datatype]
+      @datatype ||= self.class.const_get(:DATATYPE) if self.class.const_defined?(:DATATYPE)
     end
 
     ##
@@ -138,30 +156,7 @@ module RDF
     ##
     # @return [Object]
     def object
-      @object || case datatype
-        when XSD.string, nil
-          value
-        when XSD.boolean
-          %w(true 1).include?(value)
-        when XSD.integer, XSD.long, XSD.int, XSD.short, XSD.byte
-          value.to_i
-        when XSD.double, XSD.float
-          value.to_f
-        when XSD.decimal
-          ::BigDecimal.new(value)
-        when XSD.date
-          ::Date.parse(value)
-        when XSD.dateTime
-          ::DateTime.parse(value)
-        when XSD.time
-          ::Time.parse(value)
-        when XSD.nonPositiveInteger, XSD.negativeInteger
-          value.to_i
-        when XSD.nonNegativeInteger, XSD.positiveInteger
-          value.to_i
-        when XSD.unsignedLong, XSD.unsignedInt, XSD.unsignedShort, XSD.unsignedByte
-          value.to_i
-      end
+      defined?(@object) ? @object : value
     end
 
     ##
@@ -189,7 +184,7 @@ module RDF
     end
 
     ##
-    # Returns `true` if this literal is equal to `other`.
+    # Determins if `self` is the same term as `other`.
     #
     # @example
     #   RDF::Literal(1).eql?(RDF::Literal(1.0))  #=> false
@@ -199,27 +194,43 @@ module RDF
     def eql?(other)
       self.equal?(other) ||
         (self.class.eql?(other.class) &&
-         self.datatype.eql?(other.datatype) &&
-         self == other)
+         self.value.eql?(other.value) &&
+         self.language.to_s.downcase.eql?(other.language.to_s.downcase) &&
+         self.datatype.eql?(other.datatype))
     end
 
     ##
-    # Returns `true` if this literal is equivalent to `other`.
+    # Returns `true` if this literal is equivalent to `other` (with type check).
     #
     # @example
     #   RDF::Literal(1) == RDF::Literal(1.0)     #=> true
     #
     # @param  [Object] other
     # @return [Boolean] `true` or `false`
+    #
+    # @see http://www.w3.org/TR/rdf-sparql-query/#func-RDFterm-equal
+    # @see http://www.w3.org/TR/rdf-concepts/#section-Literal-Equality
     def ==(other)
       case other
-        when Literal
-          self.value.eql?(other.value) &&
-          self.language.eql?(other.language) &&
-          self.datatype.eql?(other.datatype)
-        when String
-          self.plain? && self.value.eql?(other)
-        else false
+      when Literal
+        case
+        when self.eql?(other)
+          true
+        when self.has_language? && self.language.to_s.downcase == other.language.to_s.downcase
+          # Literals with languages can compare if languages are identical
+          self.value == other.value
+        when (self.simple? || self.datatype == XSD.string) && (other.simple? || other.datatype == XSD.string)
+          self.value == other.value
+        when other.comperable_datatype?(self) || self.comperable_datatype?(other)
+          # Comoparing plain with undefined datatypes does not generate an error, but returns false
+          # From data-r2/expr-equal/eq-2-2.
+          false
+        else
+          type_error("unable to determine whether #{self.inspect} and #{other.inspect} are equivalent")
+        end
+      when String
+        self.plain? && self.value.eql?(other)
+      else false
       end
     end
     alias_method :===, :==
@@ -277,6 +288,34 @@ module RDF
       !valid?
     end
 
+    ##
+    # Returns `true` if the literal has a datatype and the comparison should
+    # return false instead of raise a type error.
+    #
+    # This behavior is intuited from SPARQL data-r2/expr-equal/eq-2-2
+    # @return [Boolean]
+    def comperable_datatype?(other)
+      return false unless self.plain? || self.has_language?
+
+      case other
+      when RDF::Literal::Numeric, RDF::Literal::Boolean,
+           RDF::Literal::Date, RDF::Literal::Time, RDF::Literal::DateTime
+        # Invald types can be compared without raising a TypeError if literal has a language (open-eq-08)
+        !other.valid? && self.has_language?
+      else
+        case other.datatype
+        when XSD.string
+          true
+        when nil
+          # A different language will not generate a type error
+          other.has_language?
+        else
+          # An unknown datatype may not be used for comparison, unless it has a language? (open-eq-8)
+          self.has_language?
+        end
+      end
+    end
+
     ##
     # Validates the value using {#valid?}, raising an error if the value is
     # invalid.