rdf 0.1.10 → 0.2.0

data/lib/rdf/mixin/queryable.rb

@@ -13,35 +13,67 @@ module RDF
     ##
     # Queries `self` for RDF statements matching the given `pattern`.
     #
+    # This method delegates to the protected {#query_pattern} method for the
+    # actual lower-level query pattern matching implementation.
+    #
     # @example
     #     queryable.query([nil, RDF::DOAP.developer, nil])
     #     queryable.query(:predicate => RDF::DOAP.developer)
     #
     # @param  [Query, Statement, Array(Value), Hash] pattern
     # @yield  [statement]
-    # @yieldparam [Statement]
-    # @return [Array<Statement>]
+    # @yieldparam [RDF::Statement]
+    # @return [Enumerator<RDF::Statement>]
+    # @see    RDF::Queryable#query_pattern
     def query(pattern, &block)
       raise TypeError.new("#{self} is not readable") if respond_to?(:readable?) && !readable?
 
       case pattern
         when Query
           pattern.execute(self, &block)
-        when Array
-          query(Statement.new(*pattern), &block)
-        when Hash
-          query(Statement.new(pattern), &block)
-        when Statement
+        else
+          pattern = case pattern
+            when Query::Pattern, Statement then pattern
+            when Array then Query::Pattern.new(*pattern)
+            when Hash  then Query::Pattern.new(pattern)
+            else raise ArgumentError.new("expected RDF::Query, RDF::Query::Pattern, Array, or Hash, but got #{pattern.inspect}")
+          end
+
           if block_given?
-            find_all { |statement| pattern === statement }.each(&block)
+            query_pattern(pattern, &block)
+            return nil
           else
-            find_all { |statement| pattern === statement }.extend(RDF::Enumerable, RDF::Queryable)
+            enum = enum_for(:query_pattern, pattern)
+            enum.extend(RDF::Queryable, RDF::Enumerable, RDF::Countable)
+            def enum.to_a
+              super.extend(RDF::Queryable, RDF::Enumerable, RDF::Countable)
+            end
+            return enum
           end
-        else
-          raise ArgumentError.new("expected RDF::Query, RDF::Pattern, Array or Hash, but got #{pattern.inspect}")
       end
     end
 
+    ##
+    # Queries `self` for RDF statements matching the given `pattern`,
+    # yielding each matched statement to the given block.
+    #
+    # Since RDF.rb 0.2.0, this is the preferred method that subclasses of
+    # `RDF::Repository` should override in order to provide an optimized
+    # query implementation.
+    #
+    # @param  [RDF::Query::Pattern] pattern
+    # @yield  [statement]
+    # @yieldparam [RDF::Statement]
+    # @return [void]
+    # @see    RDF::Queryable#query
+    # @since  0.2.0
+    def query_pattern(pattern, &block)
+      # @see http://ruby-doc.org/core/classes/Enumerable.html#M003121
+      grep(pattern, &block)
+    end
+
+    protected :query_pattern
+
     ##
     # Queries `self` for an RDF statement matching the given `pattern` and
     # returns that statement if found.

data/lib/rdf/mixin/readable.rb

@@ -1,6 +1,8 @@
 module RDF
   ##
   module Readable
+    extend RDF::Util::Aliasing::LateBound
+
     ##
     # Returns `true` if `self` is readable.
     #

data/lib/rdf/mixin/writable.rb

@@ -1,6 +1,8 @@
 module RDF
   ##
   module Writable
+    extend RDF::Util::Aliasing::LateBound
+
     ##
     # Returns `true` if `self` is writable.
     #
@@ -9,5 +11,133 @@ module RDF
     def writable?
       true
     end
+
+    ##
+    # Inserts RDF data into `self`.
+    #
+    # @param  [RDF::Enumerable, RDF::Statement, #to_rdf] data
+    # @return [Writable]
+    def <<(data)
+      case data
+        when RDF::Graph
+          insert_graph(data)
+        when RDF::Enumerable
+          insert_statements(data)
+        when RDF::Statement
+          insert_statement(data)
+        else case
+          when data.respond_to?(:to_rdf) && !data.equal?(rdf = data.to_rdf)
+            self << rdf
+          else
+            insert_statement(create_statement(data))
+        end
+      end
+
+      return self
+    end
+
+    ##
+    # Inserts RDF statements into `self`.
+    #
+    # @param  [Array<RDF::Statement>] statements
+    # @return [Writable]
+    def insert(*statements)
+      statements.map! do |value|
+        case
+          when value.respond_to?(:each_statement)
+            insert_statements(value)
+            nil
+          when (statement = create_statement(value)).valid?
+            statement
+          else
+            raise ArgumentError.new("not a valid statement: #{value.inspect}")
+        end
+      end
+      statements.compact!
+      insert_statements(statements) unless statements.empty?
+
+      return self
+    end
+
+    alias_method :insert!, :insert
+
+  protected
+
+    ##
+    # Inserts the given RDF graph into the underlying storage or output
+    # stream.
+    #
+    # Defaults to passing the graph to the {#insert_statements} method.
+    #
+    # Subclasses of {RDF::Repository} may wish to override this method in
+    # case their underlying storage architecture is graph-centric rather
+    # than statement-oriented.
+    #
+    # Subclasses of {RDF::Writer} may wish to override this method if the
+    # output format they implement supports named graphs, in which case
+    # implementing this method may help in producing prettier and more
+    # concise output.
+    #
+    # @param  [RDF::Graph] graph
+    # @return [void]
+    def insert_graph(graph)
+      insert_statements(graph)
+    end
+
+    ##
+    # Inserts the given RDF statements into the underlying storage or output
+    # stream.
+    #
+    # Defaults to invoking {#insert_statement} for each given statement.
+    #
+    # Subclasses of {RDF::Repository} may wish to override this method if
+    # they are capable of more efficiently inserting multiple statements at
+    # once.
+    #
+    # Subclasses of {RDF::Writer} don't generally need to implement this
+    # method.
+    #
+    # @param  [RDF::Enumerable] statements
+    # @return [void]
+    def insert_statements(statements)
+      each = statements.respond_to?(:each_statement) ? :each_statement : :each
+      statements.__send__(each) do |statement|
+        insert_statement(statement)
+      end
+    end
+
+    ##
+    # Inserts an RDF statement into the underlying storage or output stream.
+    #
+    # Subclasses of {RDF::Repository} must implement this method, except if
+    # they are immutable.
+    #
+    # Subclasses of {RDF::Writer} must implement this method.
+    #
+    # @param  [RDF::Statement] statement
+    # @return [void]
+    # @abstract
+    def insert_statement(statement)
+      raise NotImplementedError.new("#{self.class}#insert_statement")
+    end
+
+    ##
+    # Transforms various input into an `RDF::Statement` instance.
+    #
+    # @param  [RDF::Statement, Hash, Array, #to_a] statement
+    # @return [RDF::Statement]
+    def create_statement(statement)
+      # TODO: move this to RDF::Statement.construct or the like.
+      case statement
+        when Statement then statement
+        when Hash      then Statement.new(statement)
+        when Array     then Statement.new(*statement)
+        else raise ArgumentError.new # FIXME
+      end
+    end
+
+    protected :insert_statements
+    protected :insert_statement
+    protected :create_statement
   end
 end

data/lib/rdf/model/graph.rb

@@ -19,17 +19,26 @@ module RDF
   #   
   #   graph = RDF::Graph.load("http://www.bbc.co.uk/programmes/b0081dq5.rdf")
   #
-  class Graph < Resource
+  class Graph
+    include RDF::Resource
+
+    include RDF::Countable
     include RDF::Enumerable
-    include RDF::Mutable
     include RDF::Queryable
+    include RDF::Mutable
 
     ##
-    # @return [Resource]
+    # Returns the options passed to this graph when it was constructed.
+    #
+    # @return [Hash{Symbol => Object}]
+    attr_reader :options
+
+    ##
+    # @return [RDF::Resource]
     attr_accessor :context
 
     ##
-    # @return [Array<Statement>]
+    # @return [RDF::Queryable]
     attr_accessor :data
 
     ##
@@ -56,7 +65,7 @@ module RDF
     end
 
     ##
-    # @param  [Resource]               context
+    # @param  [RDF::Resource]          context
     # @param  [Hash{Symbol => Object}] options
     # @yield  [graph]
     # @yieldparam [Graph]
@@ -68,7 +77,7 @@ module RDF
       end
 
       @options = options.dup
-      @data    = @options.delete(:data) || []
+      @data    = @options.delete(:data) || RDF::Repository.new
 
       if block_given?
         case block.arity
@@ -115,15 +124,15 @@ module RDF
     ##
     # Returns all unique RDF contexts for this graph.
     #
-    # @return [Array<Resource>]
+    # @return [Enumerator<RDF::Resource>]
     def contexts
-      named? ? [context] : []
+      (named? ? [context] : []).to_enum.extend(RDF::Countable)
     end
 
     ##
     # Returns the URI representation of this graph.
     #
-    # @return [URI]
+    # @return [RDF::URI]
     def to_uri
       context
     end
@@ -145,13 +154,21 @@ module RDF
       @data.empty?
     end
 
+    ##
+    # Returns `true` if this graph has an anonymous context, `false` otherwise.
+    #
+    # @return [Boolean]
+    def anonymous?
+      context.nil? ? false : context.anonymous?
+    end
+
     ##
     # Returns the number of RDF statements in this graph.
     #
     # @return [Integer]
     # @see    RDF::Enumerable#count
     def count
-      @data.size
+      @data.query(:context => context).count
     end
 
     ##
@@ -163,7 +180,7 @@ module RDF
     def has_statement?(statement)
       statement = statement.dup
       statement.context = context
-      @data.include?(statement)
+      @data.has_statement?(statement)
     end
 
     ##
@@ -174,7 +191,7 @@ module RDF
     # @return [Enumerator]
     # @see    RDF::Enumerable#each_statement
     def each(&block)
-      @data.each(&block)
+      @data.query(:context => context).each(&block)
     end
 
     ##
@@ -186,7 +203,7 @@ module RDF
     def insert_statement(statement)
       statement = statement.dup
       statement.context = context
-      @data.push(statement.dup) unless @data.include?(statement)
+      @data.insert(statement)
     end
 
     ##
@@ -207,11 +224,27 @@ module RDF
     # @return [void]
     # @see    RDF::Mutable#clear
     def clear_statements
-      @data.clear
+      @data.delete(:context => context)
     end
 
     protected :insert_statement
     protected :delete_statement
     protected :clear_statements
+
+    ##
+    # @private
+    # @see    RDF::Enumerable#graphs
+    # @since  0.2.0
+    def graphs
+      enum_graph
+    end
+
+    ##
+    # @private
+    # @see    RDF::Enumerable#each_graph
+    # @since  0.2.0
+    def each_graph(&block)
+      block_given? ? block.call(self) : enum_graph
+    end
   end
 end

data/lib/rdf/model/literal.rb

@@ -38,7 +38,9 @@ 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 < Value
+  class Literal
+    include RDF::Value
+
     # @return [String] The normalized string representation of the value.
     attr_accessor :value
 
@@ -57,7 +59,7 @@ module RDF
       @language = options[:language] ? options[:language].to_s.to_sym : nil
 
       if datatype = options[:datatype]
-        @datatype = datatype.respond_to?(:to_uri) ? datatype.to_uri : URI.new(datatype.to_s)
+        @datatype = datatype.respond_to?(:to_uri) ? datatype.to_uri : URI.intern(datatype.to_s)
       else
         @datatype = case value
           when String     then nil # implicit XSD.string
@@ -137,6 +139,14 @@ module RDF
       true
     end
 
+    ##
+    # Returns `false`.
+    #
+    # @return [Boolean]
+    def anonymous?
+      false
+    end
+
     ##
     # @return [Boolean]
     def eql?(other)

data/lib/rdf/model/node.rb

@@ -11,7 +11,9 @@ module RDF
   #
   # @see http://rubygems.org/gems/uuid
   # @see http://rubygems.org/gems/uuidtools
-  class Node < Resource
+  class Node
+    include RDF::Resource
+
     ##
     # Returns a blank node with a random UUID-based identifier.
     #
@@ -30,6 +32,17 @@ module RDF
       end
     end
 
+    ##
+    # Alias for `RDF::Node.new`, at the moment.
+    #
+    # @private
+    # @param  [#to_s] id
+    # @return [RDF::Node]
+    # @since  0.2.0
+    def self.intern(id)
+      self.new(id)
+    end
+
     # @return [String]
     attr_accessor :id
 
@@ -65,12 +78,48 @@ module RDF
       !unlabeled?
     end
 
+    ##
+    # Returns a hash code for this blank node.
+    #
+    # @return [Fixnum]
+    def hash
+      @id.hash
+    end
+
+    ##
+    # Checks whether this blank node is equal to `other`.
+    #
+    # @param  [Node] other
+    # @return [Boolean]
+    def eql?(other)
+      other.is_a?(Node) && self == other
+    end
+
+    ##
+    # Checks whether this blank node is equal to `other`.
+    #
+    # @param  [Object] other
+    # @return [Boolean]
+    def ==(other)
+      other.respond_to?(:node?) && other.node? &&
+        other.respond_to?(:id) && @id == other.id
+    end
+
     ##
     # Returns a string representation of this blank node.
     #
     # @return [String]
     def to_s
-      "_:%s" % id.to_s
+      "_:%s" % @id.to_s
+    end
+
+    ##
+    # Returns a symbol representation of this blank node.
+    #
+    # @return [Symbol]
+    # @since  0.2.0
+    def to_sym
+      @id.to_s.to_sym
     end
   end
 end