rdf 0.1.10 → 0.2.0

data/lib/rdf/mixin/durable.rb

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

data/lib/rdf/mixin/enumerable.rb

@@ -57,40 +57,19 @@ module RDF
   # @see RDF::Graph
   # @see RDF::Repository
   module Enumerable
+    extend  RDF::Util::Aliasing::LateBound
+    include RDF::Countable
     include ::Enumerable
 
-    ##
-    # Returns `true` if `self` contains no RDF statements.
-    #
-    # @return [Boolean]
-    def empty?
-      empty = true
-      each_statement { empty = false; break }
-      empty
-    end
-
-    ##
-    # Returns the number of RDF statements in `self`.
-    #
-    # @return [Integer]
-    def count
-      count = 0
-      each_statement { count += 1 }
-      count
-    end
-
-    alias_method :size,   :count
-    alias_method :length, :count
-
     ##
     # Returns all RDF statements.
     #
     # @param  [Hash{Symbol => Boolean}] options
-    # @return [Array<Statement>]
+    # @return [Enumerator<Statement>]
     # @see    #each_statement
     # @see    #enum_statement
     def statements(options = {})
-      enum_statement.to_a
+      enum_statement
     end
 
     ##
@@ -99,9 +78,11 @@ module RDF
     # @param  [Statement] statement
     # @return [Boolean]
     def has_statement?(statement)
-      enum_statement.include?(statement)
+      !enum_statement.find { |s| s.eql?(statement) }.nil?
     end
 
+    alias_method :include?, :has_statement?
+
     ##
     # Iterates the given block for each RDF statement.
     #
@@ -134,7 +115,7 @@ module RDF
     # @return [Enumerator]
     # @see    #each_statement
     def enum_statement
-      Enumerator.new(self, :each_statement)
+      enum_for(:each_statement).extend(RDF::Queryable, RDF::Enumerable)
     end
 
     alias_method :enum_statements, :enum_statement
@@ -143,11 +124,11 @@ module RDF
     # Returns all RDF triples.
     #
     # @param  [Hash{Symbol => Boolean}] options
-    # @return [Array<Array(Resource, URI, Value)>]
+    # @return [Enumerator<Array(Resource, URI, Value)>]
     # @see    #each_triple
     # @see    #enum_triple
     def triples(options = {})
-      enum_statement.map { |statement| statement.to_triple }
+      enum_statement.map(&:to_triple).to_enum # TODO: optimize
     end
 
     ##
@@ -194,7 +175,7 @@ module RDF
     # @return [Enumerator]
     # @see    #each_triple
     def enum_triple
-      Enumerator.new(self, :each_triple)
+      enum_for(:each_triple)
     end
 
     alias_method :enum_triples, :enum_triple
@@ -203,11 +184,11 @@ module RDF
     # Returns all RDF quads.
     #
     # @param  [Hash{Symbol => Boolean}] options
-    # @return [Array<Array(Resource, URI, Value, Resource)>]
+    # @return [Enumerator<Array(Resource, URI, Value, Resource)>]
     # @see    #each_quad
     # @see    #enum_quad
     def quads(options = {})
-      enum_statement.map { |statement| statement.to_quad }
+      enum_statement.map(&:to_quad).to_enum # TODO: optimize
     end
 
     ##
@@ -255,7 +236,7 @@ module RDF
     # @return [Enumerator]
     # @see    #each_quad
     def enum_quad
-      Enumerator.new(self, :each_quad)
+      enum_for(:each_quad)
     end
 
     alias_method :enum_quads, :enum_quad
@@ -265,14 +246,14 @@ module RDF
     #
     # @param  [Hash{Symbol => Boolean}] options
     # @option options [Boolean] :unique (true)
-    # @return [Array<Resource>]
+    # @return [Enumerator<Resource>]
     # @see    #each_subject
     # @see    #enum_subject
     def subjects(options = {})
       if options[:unique] == false
-        enum_statement.map { |statement| statement.subject }
+        enum_statement.map(&:subject).to_enum # TODO: optimize
       else
-        enum_subject.to_a
+        enum_subject
       end
     end
 
@@ -323,7 +304,7 @@ module RDF
     # @return [Enumerator]
     # @see    #each_subject
     def enum_subject
-      Enumerator.new(self, :each_subject)
+      enum_for(:each_subject)
     end
 
     alias_method :enum_subjects, :enum_subject
@@ -333,14 +314,14 @@ module RDF
     #
     # @param  [Hash{Symbol => Boolean}] options
     # @option options [Boolean] :unique (true)
-    # @return [Array<URI>]
+    # @return [Enumerator<URI>]
     # @see    #each_predicate
     # @see    #enum_predicate
     def predicates(options = {})
       if options[:unique] == false
-        enum_statement.map { |statement| statement.predicate }
+        enum_statement.map(&:predicate).to_enum # TODO: optimize
       else
-        enum_predicate.to_a
+        enum_predicate
       end
     end
 
@@ -391,7 +372,7 @@ module RDF
     # @return [Enumerator]
     # @see    #each_predicate
     def enum_predicate
-      Enumerator.new(self, :each_predicate)
+      enum_for(:each_predicate)
     end
 
     alias_method :enum_predicates, :enum_predicate
@@ -401,14 +382,14 @@ module RDF
     #
     # @param  [Hash{Symbol => Boolean}] options
     # @option options [Boolean] :unique (true)
-    # @return [Array<Value>]
+    # @return [Enumerator<Value>]
     # @see    #each_object
     # @see    #enum_object
     def objects(options = {})
       if options[:unique] == false
-        enum_statement.map { |statement| statement.object }
+        enum_statement.map(&:object).to_enum # TODO: optimize
       else
-        enum_object.to_a
+        enum_object
       end
     end
 
@@ -459,7 +440,7 @@ module RDF
     # @return [Enumerator]
     # @see    #each_object
     def enum_object
-      Enumerator.new(self, :each_object)
+      enum_for(:each_object)
     end
 
     alias_method :enum_objects, :enum_object
@@ -469,14 +450,14 @@ module RDF
     #
     # @param  [Hash{Symbol => Boolean}] options
     # @option options [Boolean] :unique (true)
-    # @return [Array<Resource>]
+    # @return [Enumerator<Resource>]
     # @see    #each_context
     # @see    #enum_context
     def contexts(options = {})
       if options[:unique] == false
-        enum_statement.map { |statement| statement.context }
+        enum_statement.map(&:context).to_enum # TODO: optimize
       else
-        enum_context.to_a
+        enum_context
       end
     end
 
@@ -527,7 +508,7 @@ module RDF
     # @return [Enumerator]
     # @see    #each_context
     def enum_context
-      Enumerator.new(self, :each_context)
+      enum_for(:each_context)
     end
 
     alias_method :enum_contexts, :enum_context
@@ -568,11 +549,34 @@ module RDF
     # @see    #each_graph
     # @since  0.1.9
     def enum_graph
-      Enumerator.new(self, :each_graph)
+      enum_for(:each_graph)
     end
 
     alias_method :enum_graphs, :enum_graph
 
+    ##
+    # Returns all RDF statements in `self` as an array.
+    #
+    # Mixes in `RDF::Enumerable` into the returned object.
+    #
+    # @return [Array]
+    # @since  0.2.0
+    def to_a
+      super.extend(RDF::Enumerable)
+    end
+
+    ##
+    # Returns all RDF statements in `self` as a set.
+    #
+    # Mixes in `RDF::Enumerable` into the returned object.
+    #
+    # @return [Set]
+    # @since  0.2.0
+    def to_set
+      require 'set' unless defined?(::Set)
+      super.extend(RDF::Enumerable)
+    end
+
     ##
     # Returns all RDF objects indexed by their subjects and predicates.
     #
@@ -591,5 +595,23 @@ module RDF
       end
       result
     end
+
+    ##
+    # Returns a serialized string representation of `self`.
+    #
+    # Before calling this method you may need to explicitly require a
+    # serialization plugin for the specified format.
+    #
+    # @example Serializing into N-Triples format
+    #   require 'rdf/ntriples'
+    #   ntriples = enumerable.dump(:ntriples)
+    #
+    # @param  [Array<Object>] args
+    # @return [String]
+    # @see    RDF::Writer.dump
+    # @since  0.2.0
+    def dump(*args)
+      RDF::Writer.for(*args).dump(self)
+    end
   end
 end

data/lib/rdf/mixin/inferable.rb

@@ -1,6 +1,5 @@
 module RDF
   ##
-  module Inferable
-    # TODO
-  end
+  # @see http://github.com/bendiken/rdfs
+  module Inferable; end
 end

data/lib/rdf/mixin/mutable.rb

@@ -6,6 +6,7 @@ module RDF
   # @see RDF::Graph
   # @see RDF::Repository
   module Mutable
+    extend  RDF::Util::Aliasing::LateBound
     include RDF::Readable
     include RDF::Writable
 
@@ -32,11 +33,11 @@ module RDF
     #
     # @param  [String, #to_s]          filename
     # @param  [Hash{Symbol => Object}] options
-    # @return [Integer] the number of inserted RDF statements
+    # @return [void]
     def load(filename, options = {})
       raise TypeError.new("#{self} is immutable") if immutable?
 
-      Reader.open(filename, options) do |reader|
+      Reader.open(filename, {:base_uri => filename}.merge(options)) do |reader|
         if options[:context]
           statements = []
           reader.each_statement do |statement|
@@ -47,7 +48,7 @@ module RDF
           statements.size
         else
           insert_statements(reader)
-          nil # FIXME
+          nil
         end
       end
     end
@@ -55,50 +56,58 @@ module RDF
     alias_method :load!, :load
 
     ##
-    # Inserts an RDF statement into `self`.
+    # Inserts RDF data into `self`.
     #
-    # @param  [RDF::Statement, Array<RDF::Value>, #to_a] statement
+    # @param  [RDF::Enumerable, RDF::Statement, #to_rdf] data
+    # @raise  [TypeError] if `self` is immutable
     # @return [Mutable]
-    def <<(statement)
+    # @see    RDF::Writable#<<
+    def <<(data)
       raise TypeError.new("#{self} is immutable") if immutable?
 
-      insert_statement(create_statement(statement))
-
-      return self
+      super # RDF::Writable#<<
     end
 
     ##
     # Inserts RDF statements into `self`.
     #
-    # @param  [Enumerable<RDF::Statement>] statements
+    # @param  [Array<RDF::Statement>] statements
     # @raise  [TypeError] if `self` is immutable
     # @return [Mutable]
+    # @see    RDF::Writable#insert
     def insert(*statements)
       raise TypeError.new("#{self} is immutable") if immutable?
 
-      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}")
+      super # RDF::Writable#insert
+    end
+
+    ##
+    # Updates RDF statements in `self`.
+    #
+    # `#update([subject, predicate, object])` is equivalent to
+    # `#delete([subject, predicate, nil])` followed by
+    # `#insert([subject, predicate, object])` unless `object` is `nil`.
+    #
+    # @param  [Enumerable<RDF::Statement>] statements
+    # @raise  [TypeError] if `self` is immutable
+    # @return [Mutable]
+    def update(*statements)
+      raise TypeError.new("#{self} is immutable") if immutable?
+
+      statements.each do |statement|
+        if (statement = create_statement(statement))
+          delete([statement.subject, statement.predicate, nil])
+          insert(statement) if statement.has_object?
         end
       end
-      statements.compact!
-      insert_statements(statements) unless statements.empty?
-
-      return self
     end
 
-    alias_method :insert!, :insert
+    alias_method :update!, :update
 
     ##
     # Deletes RDF statements from `self`.
     #
-    # @param  [Enumerable<Statement>] statements
+    # @param  [Enumerable<RDF::Statement>] statements
     # @raise  [TypeError] if `self` is immutable
     # @return [Mutable]
     def delete(*statements)
@@ -124,32 +133,10 @@ module RDF
 
     alias_method :delete!, :delete
 
-    ##
-    # Updates RDF statements in `self`.
-    #
-    # `#update([subject, predicate, object])` is equivalent to
-    # `#delete([subject, predicate, nil])` followed by
-    # `#insert([subject, predicate, object])` unless `object` is `nil`.
-    #
-    # @param  [Enumerable<RDF::Statement>] statements
-    # @raise  [TypeError] if `self` is immutable
-    # @return [Mutable]
-    def update(*statements)
-      raise TypeError.new("#{self} is immutable") if immutable?
-
-      statements.each do |statement|
-        if (statement = create_statement(statement))
-          delete([statement.subject, statement.predicate, nil])
-          insert(statement) if statement.has_object?
-        end
-      end
-    end
-
-    alias_method :update!, :update
-
     ##
     # Deletes all RDF statements from `self`.
     #
+    # @raise  [TypeError] if `self` is immutable
     # @return [Mutable]
     def clear
       raise TypeError.new("#{self} is immutable") if immutable?
@@ -157,91 +144,48 @@ module RDF
       if respond_to?(:clear_statements)
         clear_statements
       else
-        each_statement do |statement|
-          delete_statement(statement)
-        end
+        delete_statements(self)
       end
-      self
+
+      return self
     end
 
     alias_method :clear!, :clear
 
-    ##
-    # Transforms various input into an `RDF::Statement` instance.
-    #
-    # @param  [RDF::Statement, Hash, Array, #to_a] statement
-    # @return [RDF::Statement]
-    def create_statement(statement)
-      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
 
     ##
-    # Inserts an RDF statement into the underlying storage.
+    # Deletes the given RDF statements from the underlying storage.
     #
-    # Subclasses of {RDF::Repository} must implement this method (except in
-    # case they are immutable).
+    # Defaults to invoking {#delete_statement} for each given statement.
     #
-    # @param  [RDF::Statement] statement
-    # @return [void]
-    # @abstract
-    def insert_statement(statement)
-      raise NotImplementedError
-    end
-
-    ##
-    # Inserts a list of RDF statement into the underlying storage.
+    # Subclasses of {RDF::Repository} may wish to override this method if
+    # they are capable of more efficiently deleting multiple statements at
+    # once.
     #
-    # Subclasses of {RDF::Repository} may implement this method if they can
-    # efficiently insert multiple statements at once. This will otherwise
-    # default to invoking {#insert_statement} for each given statement.
-    #
-    # @param  [RDF::Enumerable, #each] statements
+    # @param  [RDF::Enumerable] statements
     # @return [void]
-    def insert_statements(statements)
+    def delete_statements(statements)
       each = statements.respond_to?(:each_statement) ? :each_statement : :each
       statements.__send__(each) do |statement|
-        insert_statement(statement)
+        delete_statement(statement)
       end
     end
 
     ##
     # Deletes an RDF statement from the underlying storage.
     #
-    # Subclasses of {RDF::Repository} must implement this method (except in
-    # case they are immutable).
+    # Subclasses of {RDF::Repository} must implement this method, except if
+    # they are immutable.
     #
     # @param  [RDF::Statement] statement
     # @return [void]
     # @abstract
     def delete_statement(statement)
-      raise NotImplementedError
-    end
-
-    ##
-    # Deletes a list of RDF statement from the underlying storage.
-    #
-    # Subclasses of {RDF::Repository} may implement this method if they can
-    # efficiently delete multiple statements at once. This will otherwise
-    # default to invoking {#delete_statement} for each given statement.
-    #
-    # @param  [RDF::Enumerable, #each] statements
-    # @return [void]
-    def delete_statements(statements)
-      each = statements.respond_to?(:each_statement) ? :each_statement : :each
-      statements.__send__(each) do |statement|
-        delete_statement(statement)
-      end
+      raise NotImplementedError.new("#{self.class}#delete_statement")
     end
 
-    protected :create_statement
-    protected :insert_statement
-    protected :insert_statements
-    protected :delete_statement
     protected :delete_statements
+    protected :delete_statement
   end
 end