rdf 0.0.6 → 0.0.7

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

@@ -66,6 +66,18 @@ module RDF
       end
     end
 
+    ##
+    # @return [Boolean]
+    def invalid?
+      !valid?
+    end
+
+    ##
+    # @return [Boolean]
+    def valid?
+      has_subject? && has_predicate? && has_object?
+    end
+
     ##
     # @return [Boolean]
     def asserted?

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

@@ -21,11 +21,19 @@ module RDF
     end
 
     ##
-    # @param  [URI, String, #to_s] uri
-    def initialize(uri)
-      @uri = case uri
-        when Addressable::URI then uri
-        else Addressable::URI.parse(uri.to_s)
+    # @overload uri(uri)
+    #   @param  [URI, String, #to_s]    uri
+    #
+    # @overload uri(options = {})
+    #   @param  [Hash{Symbol => Object} options
+    def initialize(uri_or_options)
+      case uri_or_options
+        when Hash
+          @uri = Addressable::URI.new(uri_or_options)
+        when Addressable::URI
+          @uri = uri_or_options
+        else
+          @uri = Addressable::URI.parse(uri_or_options.to_s)
       end
     end
 
@@ -56,13 +64,18 @@ module RDF
     # @param  [Object] other
     # @return [Boolean]
     def ==(other)
-      other.respond_to?(:to_uri) && @uri == other.to_uri
+      case other
+        when Addressable::URI
+          to_s == other.to_s
+        else
+          other.respond_to?(:to_uri) && to_s == other.to_uri.to_s
+      end
     end
 
     ##
     # @return [URI]
     def to_uri
-      @uri
+      self
     end
 
     ##

data/lib/rdf/model/value.rb

@@ -0,0 +1,135 @@
+module RDF
+  ##
+  # An RDF value.
+  #
+  # This is the base class for the RDF.rb class hierarchy. The class of
+  # every object that can be a component of {RDF::Statement statements} is a
+  # subclass of this class.
+  #
+  # @example Checking if a value is a resource (blank node or URI reference)
+  #   value.resource?
+  #
+  # @example Checking if a value is a blank node
+  #   value.node?
+  #
+  # @example Checking if a value is a URI reference
+  #   value.uri?
+  #   value.iri?
+  #
+  # @example Checking if a value is a literal
+  #   value.literal?
+  #
+  # @abstract
+  # @see RDF::Graph
+  # @see RDF::Literal
+  # @see RDF::Node
+  # @see RDF::Resource
+  # @see RDF::Statement
+  # @see RDF::URI
+  class Value
+    include Comparable
+
+    # Prevent the instantiation of this class.
+    private_class_method :new
+
+    ##
+    # Returns `true` if this value is a graph.
+    #
+    # @return [Boolean]
+    def graph?
+      false
+    end
+
+    ##
+    # Returns `true` if this value is a literal.
+    #
+    # @return [Boolean]
+    def literal?
+      false
+    end
+
+    ##
+    # Returns `true` if this value is a blank node.
+    #
+    # @return [Boolean]
+    def node?
+      false
+    end
+
+    ##
+    # Returns `true` if this value is a resource.
+    #
+    # @return [Boolean]
+    def resource?
+      false
+    end
+
+    ##
+    # Returns `true` if this value is a statement.
+    #
+    # @return [Boolean]
+    def statement?
+      false
+    end
+
+    ##
+    # Returns `true` if this value is a URI reference.
+    #
+    # @return [Boolean]
+    def uri?
+      false
+    end
+
+    alias_method :iri?, :uri?
+
+    ##
+    # Compares this value to `other` for sorting purposes.
+    #
+    # Subclasses should override this to provide a more meaningful
+    # implementation than the default which simply performs a string
+    # comparison based on `#to_s`.
+    #
+    # @abstract
+    # @param  [Object]  other
+    # @return [Integer] -1, 0, 1
+    def <=>(other)
+      self.to_s <=> other.to_s
+    end
+
+    ##
+    # Returns an RDF::Value representation of this object.
+    #
+    # @return [Value]
+    def to_rdf
+      self
+    end
+
+    ##
+    # Returns a developer-friendly representation of this value.
+    #
+    # The result will be of the format `#<RDF::Value::0x12345678(...)>`,
+    # where `...` is the string returned by `#to_s`.
+    #
+    # @return [String]
+    def inspect
+      sprintf("#<%s:%#0x(%s)>", self.class.name, object_id, to_s)
+    end
+
+    ##
+    # Outputs a developer-friendly representation of this value to `stderr`.
+    #
+    # @return [void]
+    def inspect!
+      warn(inspect)
+    end
+
+    private
+
+      def self.inherited(child) #:nodoc:
+        # Enable the instantiation of any subclasses.
+        child.send(:public_class_method, :new)
+        super
+      end
+
+  end
+end

data/lib/rdf/ntriples.rb

@@ -1,11 +1,44 @@
 module RDF
   ##
-  # N-Triples serialization format.
+  # **`RDF::NTriples`** provides support for the N-Triples serialization
+  # format.
+  #
+  # N-Triples is a line-based plain-text format for encoding an RDF graph.
+  # It is a very restricted, explicit and well-defined subset of both
+  # [Turtle](http://www.w3.org/TeamSubmission/turtle/) and
+  # [Notation3](http://www.w3.org/TeamSubmission/n3/) (N3).
+  #
+  # The MIME content type for N-Triples files is `text/plain` and the
+  # recommended file extension is `.nt`.
+  #
+  # An example of an RDF statement in N-Triples format:
+  #
+  #     <http://rubyforge.org/> <http://purl.org/dc/terms/title> "RubyForge" .
+  #
+  # Installation
+  # ------------
+  #
+  # This is the only RDF serialization format that is directly supported by
+  # RDF.rb. Support for other formats is available in the form of add-on
+  # gems, e.g. 'rdf-xml' or 'rdf-json'.
+  #
+  # Documentation
+  # -------------
+  #
+  # * {RDF::NTriples::Format}
+  # * {RDF::NTriples::Reader}
+  # * {RDF::NTriples::Writer}
+  #
+  # @example Requiring the `RDF::NTriples` module explicitly
+  #   require 'rdf/ntriples'
   #
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
   # @see http://en.wikipedia.org/wiki/N-Triples
+  # @see http://librdf.org/ntriples/
+  #
+  # @author [Arto Bendiken](http://ar.to/)
   module NTriples
-    autoload :Format, 'rdf/ntriples/format'
+    require 'rdf/ntriples/format'
     autoload :Reader, 'rdf/ntriples/reader'
     autoload :Writer, 'rdf/ntriples/writer'
   end

data/lib/rdf/ntriples/format.rb

@@ -1,4 +1,4 @@
-module RDF module NTriples
+module RDF::NTriples
   ##
   # N-Triples format specification.
   #
@@ -7,7 +7,7 @@ module RDF module NTriples
     content_type     'text/plain', :extension => :nt
     content_encoding 'ascii'
 
-    reader RDF::NTriples::Reader
-    writer RDF::NTriples::Format
+    reader { RDF::NTriples::Reader }
+    writer { RDF::NTriples::Writer }
   end
-end end
+end

data/lib/rdf/ntriples/reader.rb

@@ -1,4 +1,4 @@
-module RDF module NTriples
+module RDF::NTriples
   ##
   # N-Triples parser.
   #
@@ -84,4 +84,4 @@ module RDF module NTriples
       string
     end
   end
-end end
+end

data/lib/rdf/ntriples/writer.rb

@@ -1,8 +1,8 @@
-module RDF module NTriples
+module RDF::NTriples
   ##
   # N-Triples serializer.
   #
-  # @see <http://www.w3.org/TR/rdf-testcases/#ntriples>
+  # @see http://www.w3.org/TR/rdf-testcases/#ntriples
   class Writer < RDF::Writer
     format RDF::NTriples::Format
 
@@ -19,32 +19,39 @@ module RDF module NTriples
     # @param  [Value]    object
     # @return [void]
     def write_triple(subject, predicate, object)
-      s = format_uri(subject)
-      p = format_uri(predicate)
-      o = object.kind_of?(RDF::URI) ? format_uri(object) : format_literal(object)
-      puts "%s %s %s ." % [s, p, o]
+      puts "%s %s %s ." % [subject, predicate, object].map { |value| format_value(value) }
     end
 
     ##
-    # @param  [node] Resource
-    # @return [void]
-    def format_uri(node)
-      "<%s>" % uri_for(node)
+    # @param  [URI]                    value
+    # @param  [Hash{Symbol => Object}] options
+    # @return [String]
+    def format_uri(value, options = {})
+      "<%s>" % uri_for(value)
     end
 
     ##
-    # @param  [String, Literal] literal
-    # @return [void]
-    def format_literal(literal)
-      case literal
+    # @param  [Node]                   value
+    # @param  [Hash{Symbol => Object}] options
+    # @return [String]
+    def format_node(value, options = {})
+      "_:%s" % node.id
+    end
+
+    ##
+    # @param  [Literal, String, #to_s] value
+    # @param  [Hash{Symbol => Object}] options
+    # @return [String]
+    def format_literal(value, options = {})
+      case value
         when RDF::Literal
-          text = quoted(escaped(literal.value))
-          text << "@#{literal.language}" if literal.language
-          text << "^^<#{uri_for(literal.datatype)}>" if literal.datatype
+          text = quoted(escaped(value.value))
+          text << "@#{value.language}" if value.language
+          text << "^^<#{uri_for(value.datatype)}>" if value.datatype
           text
         else
-          quoted(escaped(literal.to_s))
+          quoted(escaped(value.to_s))
       end
     end
   end
-end end
+end

data/lib/rdf/query.rb

@@ -41,7 +41,7 @@ module RDF
     autoload :Solution, 'rdf/query/solution'
     autoload :Variable, 'rdf/query/variable'
 
-    include Enumerable
+    include ::Enumerable
 
     # @return [Hash{Symbol => Variable}]
     attr_reader :variables
@@ -75,7 +75,7 @@ module RDF
     #
     # @yield  [solution]
     # @yieldparam [Solution]
-    # @return [Enumerable]
+    # @return [Enumerator]
     def each_solution(&block)
       solutions.each do |bindings|
         block.call(Solution.new(bindings))
@@ -123,7 +123,7 @@ module RDF
     ##
     # Reorders the solution sequence based on `variables`.
     #
-    # @param  [Enumerable<Symbol>] variables
+    # @param  [Array<Symbol>] variables
     # @return [Query]
     def order(*variables)
       if variables.empty?
@@ -145,7 +145,7 @@ module RDF
     ##
     # Restricts the the solution sequence to the given `variables` only.
     #
-    # @param  [Enumerable<Symbol>] variables
+    # @param  [Array<Symbol>] variables
     # @return [Query]
     def project(*variables)
       unless variables.empty?

data/lib/rdf/query/pattern.rb

@@ -1,7 +1,7 @@
-module RDF class Query
+class RDF::Query
   ##
   # An RDF query pattern.
-  class Pattern < Statement
+  class Pattern < RDF::Statement
     # @return [Hash{Symbol => Object}]
     attr_reader :options
 
@@ -149,4 +149,4 @@ module RDF class Query
       end
     end
   end
-end end
+end

data/lib/rdf/query/solution.rb

@@ -1,4 +1,4 @@
-module RDF class Query
+class RDF::Query
   ##
   # An RDF query solution.
   #
@@ -136,4 +136,4 @@ module RDF class Query
       end
 
   end
-end end
+end

data/lib/rdf/query/variable.rb

@@ -1,4 +1,4 @@
-module RDF class Query
+class RDF::Query
   ##
   # An RDF query variable.
   #
@@ -38,7 +38,7 @@ module RDF class Query
   #   var = RDF::Query::Variable.new(:y, 123)
   #   var.to_s       #=> "?y=123"
   #
-  class Variable < Value
+  class Variable < RDF::Value
     # @return [Symbol] The variable's name.
     attr_accessor :name
 
@@ -142,4 +142,4 @@ module RDF class Query
       unbound? ? "?#{name}" : "?#{name}=#{value}"
     end
   end
-end end
+end

data/lib/rdf/reader.rb

@@ -2,41 +2,114 @@ module RDF
   ##
   # An RDF parser.
   #
+  # @example Iterating over known RDF reader classes
+  #   RDF::Reader.each { |klass| puts klass.name }
+  #
+  # @example Obtaining an RDF reader class
+  #   RDF::Reader.for(:ntriples)     #=> RDF::NTriples::Reader
+  #   RDF::Reader.for("spec/data/test.nt")
+  #   RDF::Reader.for(:file_name => "spec/data/test.nt")
+  #   RDF::Reader.for(:file_extension => "nt")
+  #   RDF::Reader.for(:content_type => "text/plain")
+  #
+  # @example Instantiating an RDF reader class
+  #   RDF::Reader.for(:ntriples).new($stdin) { |reader| ... }
+  #
+  # @example Parsing RDF statements from a file
+  #   RDF::Reader.open("spec/data/test.nt") do |reader|
+  #     reader.each_statement do |statement|
+  #       puts statement.inspect
+  #     end
+  #   end
+  #
+  # @example Parsing RDF statements from a string
+  #   data = StringIO.new(File.read("spec/data/test.nt"))
+  #   RDF::Reader.for(:ntriples).new(data) do |reader|
+  #     reader.each_statement do |statement|
+  #       puts statement.inspect
+  #     end
+  #   end
+  #
   # @abstract
+  # @see RDF::Format
+  # @see RDF::Writer
   class Reader
-    autoload :NTriples, 'rdf/reader/ntriples' # @deprecated
-
-    include Enumerable
+    extend  ::Enumerable
+    include ::Enumerable
 
     ##
     # Enumerates known RDF reader classes.
     #
     # @yield  [klass]
     # @yieldparam [Class]
+    # @return [Enumerator]
     def self.each(&block)
-      !block_given? ? @@subclasses : @@subclasses.each { |klass| yield klass }
+      @@subclasses.each(&block)
+    end
+
+    ##
+    # Finds an RDF reader class based on the given criteria.
+    #
+    # @overload for(format)
+    #   Finds an RDF reader class based on a symbolic name.
+    #
+    #   @param  [Symbol] format
+    #   @return [Class]
+    #
+    # @overload for(filename)
+    #   Finds an RDF reader class based on a file name.
+    #
+    #   @param  [String] filename
+    #   @return [Class]
+    #
+    # @overload for(options = {})
+    #   Finds an RDF reader 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 = {})
+      if format = Format.for(options)
+        format.reader
+      end
     end
 
     ##
-    # @param  [Symbol] format
+    # Retrieves the RDF serialization format class for this writer class.
+    #
     # @return [Class]
-    def self.for(format)
-      klass = case format.to_s.downcase.to_sym
-        when :ntriples then RDF::NTriples::Reader
-        else nil # FIXME
+    def self.format(klass = nil)
+      if klass.nil?
+        Format.each do |format|
+          if format.reader == self
+            return format
+          end
+        end
+        nil # not found
       end
     end
 
+    class << self
+      alias_method :format_class, :format
+    end
+
     ##
     # @param  [String] filename
     # @option options [Symbol] :format (:ntriples)
     # @yield  [reader]
     # @yieldparam [Reader]
+    # @raise  [FormatError] if no reader available for the specified format
     def self.open(filename, options = {}, &block)
-      options[:format] ||= :ntriples # FIXME
-
       File.open(filename, 'rb') do |file|
-        self.for(options[:format]).new(file, options, &block)
+        if reader = self.for(options[:format] || filename)
+          reader.new(file, options, &block)
+        else
+          raise FormatError.new("unknown RDF format: #{options[:format] || filename}")
+        end
       end
     end
 
@@ -118,10 +191,6 @@ module RDF
         super
       end
 
-      def self.format(klass)
-        # TODO
-      end
-
       def lineno
         @input.lineno
       end