rdf 0.0.6 → 0.0.7

data/lib/rdf/format.rb

@@ -1,20 +1,125 @@
 module RDF
   ##
   # An RDF serialization format.
+  #
+  # @example Iterating over known RDF serialization formats
+  #   RDF::Format.each { |klass| puts klass.name }
+  #
+  # @example Getting a serialization format class
+  #   RDF::Format.for(:ntriples)     #=> RDF::NTriples::Format
+  #   RDF::Format.for("spec/data/test.nt")
+  #   RDF::Format.for(:file_name => "spec/data/test.nt")
+  #   RDF::Format.for(:file_extension => "nt")
+  #   RDF::Format.for(:content_type => "text/plain")
+  #
+  # @example Obtaining serialization format MIME types
+  #   RDF::Format.content_types      #=> {"text/plain" => [RDF::NTriples::Format]}
+  #
+  # @example Obtaining serialization format file extension mappings
+  #   RDF::Format.file_extensions    #=> {:nt => "text/plain"}
+  #
+  # @example Defining a new RDF serialization format class
+  #   class RDF::NTriples::Format < RDF::Format
+  #     content_type     'text/plain', :extension => :nt
+  #     content_encoding 'ascii'
+  #     
+  #     reader RDF::NTriples::Reader
+  #     writer RDF::NTriples::Writer
+  #   end
+  #
+  # @example Instantiating an RDF reader or writer class (1)
+  #   RDF::Format.for(:ntriples).reader.new($stdin)  { |reader| ... }
+  #   RDF::Format.for(:ntriples).writer.new($stdout) { |writer| ... }
+  #
+  # @example Instantiating an RDF reader or writer class (2)
+  #   RDF::Reader.for(:ntriples).new($stdin)  { |reader| ... }
+  #   RDF::Writer.for(:ntriples).new($stdout) { |writer| ... }
+  #
+  # @abstract
+  # @see RDF::Reader
+  # @see RDF::Writer
+  # @see http://en.wikipedia.org/wiki/Resource_Description_Framework#Serialization_formats
   class Format
-    include Enumerable
+    extend ::Enumerable
 
     ##
-    # Enumerates known RDF format classes.
+    # Enumerates known RDF serialization format classes.
     #
     # @yield  [klass]
     # @yieldparam [Class]
+    # @return [Enumerator]
     def self.each(&block)
-      !block_given? ? @@subclasses : @@subclasses.each { |klass| yield klass } # FIXME: Enumerator
+      @@subclasses.each(&block)
     end
 
     ##
-    # Returns the list of known MIME content types.
+    # Finds an RDF serialization format class based on the given criteria.
+    #
+    # @overload for(format)
+    #   Finds an RDF serialization format class based on a symbolic name.
+    #
+    #   @param  [Symbol] format
+    #   @return [Class]
+    #
+    # @overload for(filename)
+    #   Finds an RDF serialization format class based on a file name.
+    #
+    #   @param  [String] filename
+    #   @return [Class]
+    #
+    # @overload for(options = {})
+    #   Finds an RDF serialization format class based on various options.
+    #
+    #   @param  [Hash{Symbol => Object}] options
+    #   @option options [String, #to_s]   :file_name      (nil)
+    #   @option options [Symbol, #to_sym] :file_extension (nil)
+    #   @option options [String, #to_s]   :content_type   (nil)
+    #   @return [Class]
+    #
+    # @return [Class]
+    def self.for(options = {})
+      case options
+        when String
+          # Find a format based on the file name
+          self.for(:file_name => options)
+
+        when Hash
+          case
+            # 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
+            # Find a format based on the MIME content type
+            when mime_type = options[:content_type]
+              if content_types.has_key?(mime_type = mime_type.to_s)
+                content_types[mime_type].first
+              end
+          end
+
+        when Symbol
+          case format = options
+            # Special case, since we want this to work despite autoloading
+            when :ntriples
+              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)
+                  return klass
+                end
+              end
+              nil # not found
+          end
+      end
+    end
+
+    ##
+    # Returns MIME content types for known RDF serialization formats.
     #
     # @return [Hash{String => Array<Class>}]
     def self.content_types
@@ -22,7 +127,7 @@ module RDF
     end
 
     ##
-    # Returns the list of known file extensions.
+    # Returns file extensions for known RDF serialization formats.
     #
     # @return [Hash{Symbol => String}]
     def self.file_extensions
@@ -30,66 +135,159 @@ module RDF
     end
 
     ##
-    # @param  [Symbol] format
-    # @return [Class]
-    def self.for(format)
-      klass = case format.to_s.downcase.to_sym
-        when :ntriples then RDF::NTriples::Format
-        else nil # FIXME
+    # Retrieves or defines the reader class for this RDF serialization
+    # format.
+    #
+    # @overload reader(klass)
+    #   Defines the reader class for this RDF serialization format.
+    #   
+    #   The class should be a subclass of {RDF::Reader}, or implement the
+    #   same interface.
+    #   
+    #   @param  [Class] klass
+    #   @return [void]
+    #
+    # @overload reader
+    #   Defines the reader class for this RDF serialization format.
+    #   
+    #   The block should return a subclass of {RDF::Reader}, or a class that
+    #   implements the same interface. The block won't be invoked until the
+    #   reader class is first needed.
+    #   
+    #   @yield
+    #   @yieldreturn [Class] klass
+    #   @return [void]
+    #
+    # @overload reader
+    #   Retrieves the reader class for this RDF serialization format.
+    #   
+    #   @return [Class]
+    #
+    # @return [void]
+    def self.reader(klass = nil, &block)
+      case
+        when klass
+          @@readers[self] = klass
+        when block_given?
+          @@readers[self] = block
+        else
+          klass = @@readers[self]
+          klass = @@readers[self] = klass.call if klass.is_a?(Proc)
+          klass
       end
     end
 
     ##
-    # @yield  [format]
-    # @yieldparam [Format]
-    def initialize(options = {}, &block)
-      @options = options
-
-      if block_given?
-        case block.arity
-          when 1 then block.call(self)
-          else instance_eval(&block)
-        end
+    # Retrieves or defines the writer class for this RDF serialization
+    # format.
+    #
+    # @overload writer(klass)
+    #   Defines the writer class for this RDF serialization format.
+    #   
+    #   The class should be a subclass of {RDF::Writer}, or implement the
+    #   same interface.
+    #   
+    #   @param  [Class] klass
+    #   @return [void]
+    #
+    # @overload writer
+    #   Defines the writer class for this RDF serialization format.
+    #   
+    #   The block should return a subclass of {RDF::Writer}, or a class that
+    #   implements the same interface. The block won't be invoked until the
+    #   writer class is first needed.
+    #   
+    #   @yield
+    #   @yieldreturn [Class] klass
+    #   @return [void]
+    #
+    # @overload writer
+    #   Retrieves the writer class for this RDF serialization format.
+    #   
+    #   @return [Class]
+    #
+    # @return [void]
+    def self.writer(klass = nil, &block)
+      case
+        when klass
+          @@writers[self] = klass
+        when block_given?
+          @@writers[self] = block
+        else
+          klass = @@writers[self]
+          klass = @@writers[self] = klass.call if klass.is_a?(Proc)
+          klass
       end
     end
 
-    protected
-
-      @@subclasses       = [] # @private
-      @@file_extensions  = {} # @private
-      @@content_types    = {} # @private
-      @@content_encoding = {} # @private
+    class << self
+      alias_method :reader_class, :reader
+      alias_method :writer_class, :writer
+    end
 
-      def self.inherited(child) # @private
-        @@subclasses << child
-        super
-      end
+    protected
 
+      ##
+      # Defines a required Ruby library for this RDF serialization format.
+      #
+      # The given library will be required lazily, i.e. only when it is
+      # actually first needed, such as when instantiating a reader or parser
+      # instance for this format.
+      #
+      # @param  [String, #to_s] library
+      # @return [void]
       def self.require(library)
-        # TODO
+        (@@requires[self] ||= []) << library.to_s
       end
 
+      ##
+      # Defines MIME content types for this RDF serialization format.
+      #
+      # Optionally also defines a file extension, or a list of file
+      # extensions, that should be mapped to the given MIME type and handled
+      # by this class.
+      #
+      # @param  [String]                 type
+      # @param  [Hash{Symbol => Object}] options
+      # @option options [Symbol]         :extension  (nil)
+      # @option options [Array<Symbol>]  :extensions (nil)
+      # @return [void]
       def self.content_type(type, options = {})
-        @@content_types[type] ||= []
-        @@content_types[type] << self
+        (@@content_types[type] ||= []) << self
 
-        if options[:extension]
-          extensions = [options[:extension]].flatten.map { |ext| ext.to_sym }
+        if extensions = (options[:extension] || options[:extensions])
+          extensions = [extensions].flatten.map { |ext| ext.to_sym }
           extensions.each { |ext| @@file_extensions[ext] = type }
         end
       end
 
+      ##
+      # Defines the content encoding for this RDF serialization format.
+      #
+      # @param  [#to_sym] encoding
+      # @return [void]
       def self.content_encoding(encoding)
         @@content_encoding[self] = encoding.to_sym
       end
 
-      def self.reader(klass)
-        # TODO
-      end
+    private
+
+      private_class_method :new
 
-      def self.writer(klass)
-        # TODO
+      @@subclasses       = [] # @private
+      @@requires         = {} # @private
+      @@file_extensions  = {} # @private
+      @@content_types    = {} # @private
+      @@content_encoding = {} # @private
+      @@readers          = {} # @private
+      @@writers          = {} # @private
+
+      def self.inherited(child) # @private
+        @@subclasses << child
+        super
       end
 
   end
+
+  class FormatError < IOError; end
 end

data/lib/rdf/model/graph.rb

@@ -0,0 +1,82 @@
+module RDF
+  ##
+  # An RDF graph.
+  class Graph < Resource
+    include RDF::Enumerable
+
+    # @return [URI]
+    attr_accessor :uri
+
+    # @return [Array<Statement>]
+    attr_accessor :data
+
+    ##
+    # @param  [URI] uri
+    # @yield  [graph]
+    # @yieldparam [Graph]
+    def initialize(uri = nil, options = {}, &block)
+      @uri, @options = uri, options
+
+      if block_given?
+        case block.arity
+          when 1 then block.call(self)
+          else instance_eval(&block)
+        end
+      end
+    end
+
+    ##
+    # Returns `true`.
+    #
+    # @return [Boolean]
+    def graph?
+      true
+    end
+
+    ##
+    # @return [Boolean]
+    def named?()   !unnamed? end
+
+    ##
+    # @return [Boolean]
+    def unnamed?() uri.nil? end
+
+    ##
+    # @return [Integer]
+    def size() @data.size end
+
+    ##
+    # @yield [statement]
+    # @yieldparam [Array<Statement>]
+    # @return [Graph]
+    def each(&block)
+      @data.each(&block)
+    end
+
+    ##
+    # @return [Resource]
+    def context() uri end
+
+    ##
+    # @param  [Statement, Array(Value)]
+    # @return [Graph]
+    def <<(statement)
+      @data << case statement
+        when Array     then Statement.new(*statement)
+        when Statement then statement
+        else statement
+      end
+      self
+    end
+
+    ##
+    # @return [URI]
+    def to_uri() uri end
+
+    ##
+    # @return [String]
+    def to_s
+      named? ? uri.to_s : "<>"
+    end
+  end
+end

data/lib/rdf/{literal.rb → model/literal.rb}

@@ -29,8 +29,8 @@ module RDF
   # @example Creating implicitly datatyped literals
   #   RDF::Literal.new(false).datatype               #=> XSD.boolean
   #   RDF::Literal.new(true).datatype                #=> XSD.boolean
-  #   RDF::Literal.new(123).datatype                 #=> XSD.int
-  #   RDF::Literal.new(9223372036854775807).datatype #=> XSD.long
+  #   RDF::Literal.new(123).datatype                 #=> XSD.integer
+  #   RDF::Literal.new(9223372036854775807).datatype #=> XSD.integer
   #   RDF::Literal.new(3.1415).datatype              #=> XSD.double
   #   RDF::Literal.new(Time.now).datatype            #=> XSD.dateTime
   #   RDF::Literal.new(Date.new(2010)).datatype      #=> XSD.date
@@ -63,8 +63,8 @@ module RDF
           when String     then nil # implicit XSD.string
           when TrueClass  then XSD.boolean
           when FalseClass then XSD.boolean
-          when Fixnum     then XSD.int
-          when Integer    then XSD.long # FIXME
+          when Fixnum     then XSD.integer
+          when Integer    then XSD.integer
           when Float
             @value = case
               when value.nan? then 'NaN'
@@ -80,12 +80,55 @@ module RDF
               when Date     then XSD.date
               when Time     then XSD.dateTime
             end
+          else
+            require 'bigdecimal' unless defined?(BigDecimal)
+            case value
+              when BigDecimal
+                case
+                  when value.nan?      then 'NaN'
+                  when value.infinite? then value.to_s[0...-'inity'.length].upcase
+                  when value.finite?   then value.to_s('F')
+              end
+            end
         end
       end
 
       @value = @value.to_s
     end
 
+    ##
+    # @return [Object]
+    def object
+      case datatype
+        when XSD.string, nil
+          value
+        when XSD.boolean
+          %w(true 1).include?(value)
+        when XSD.double, XSD.float
+          value.to_f
+        when XSD.integer, XSD.long, XSD.int, XSD.short, XSD.byte
+          value.to_i
+        when XSD.decimal
+          require 'bigdecimal' unless defined?(BigDecimal)
+          BigDecimal.new(value)
+        when XSD.date
+          require 'date' unless defined?(Date)
+          Date.parse(value)
+        when XSD.dateTime
+          require 'date' unless defined?(DateTime)
+          DateTime.parse(value)
+        when XSD.time
+          require '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
+    end
+
     ##
     # Returns `true`.
     #