ugly but all tests pass

Author: doriantaylor

.gitignore

@@ -12,3 +12,5 @@ Gemfile.lock
 benchmark/
 /.byebug_history
 /coverage/
+\#*\#
+.\#*

lib/rdf/changeset.rb

@@ -31,10 +31,11 @@ module RDF
   #
   # @since 2.0.0
   class Changeset
-    include RDF::Mutable
+    # include RDF::Mutable
+    include RDF::Util::Coercions
 
     ##
-    # Applies a changeset to the given mutable RDF::Enumerable .
+    # Applies a changeset to the given {RDF::Mutable} object.
     #
     # @param  [RDF::Mutable] mutable
     # @param  [Hash{Symbol => Object}] options
@@ -86,9 +87,9 @@ def initialize(insert: [], delete: [], &block)
     end
 
     ##
-    # Returns `false` to indicate that this changeset is append-only.
+    # Returns +false+ to indicate that this changeset is append-only.
     #
-    # Changesets do not support the `RDF::Enumerable` protocol directly.
+    # Changesets do not support the +RDF::Enumerable+ protocol directly.
     # To enumerate the RDF statements to be inserted or deleted, use the
     # {RDF::Changeset#inserts} and {RDF::Changeset#deletes} accessors.
     #
@@ -98,6 +99,14 @@ def readable?
       false
     end
 
+    def writable?
+      false
+    end
+
+    def mutable?
+      false
+    end
+
     ##
     # Applies this changeset to the given mutable RDF::Enumerable.
     #
@@ -111,7 +120,7 @@ def apply(mutable, **options)
     end
 
     ##
-    # @return [Boolean] `true` iff inserts and deletes are both empty
+    # @return [Boolean] +true+ iff inserts and deletes are both empty
     def empty?
       deletes.empty? && inserts.empty?
     end
@@ -127,41 +136,77 @@ def inspect
 
     ##
     # Outputs a developer-friendly representation of this changeset to
-    # `stderr`.
+    # +$stderr+.
     #
     # @return [void]
     def inspect!
       $stderr.puts(self.inspect)
     end
 
-    protected
-
     ##
-    # Appends an RDF statement to the sequence to insert when applied.
+    # Returns the sum of both the +inserts+ and +deletes+ counts.
     #
-    # @param  [RDF::Statement] statement
-    # @return [void]
-    # @see    RDF::Writable#insert_statement
-    def insert_statement(statement)
-      self.inserts << statement
+    # @return [Integer]
+    def count
+      inserts.count + deletes.count
     end
 
-    ##
-    # Appends an RDF statement to the sequence to delete when applied.
+    # Append statements to +inserts+. Statements _should_ be constant
+    # as variable statements will at best be ignored or at worst raise
+    # an error when applied.
     #
-    # @param  [RDF::Statement] statement
-    # @return [void]
-    # @see    RDF::Mutable#delete_statement
-    def delete_statement(statement)
-      self.deletes << statement
+    # @param statements [Enumerable, # RDF::Statement] Some statements
+    # @return [self]
+    def insert(*statements)
+      process_statements(statements) do |stmts|
+        append_statements :inserts, stmts
+      end
+
+      self
+    end
+    alias_method :insert!, :insert
+    alias_method :<<, :insert
+
+    # Append statements to +deletes+. Statements _may_ contain
+    # variables, although support will depend on the {RDF::Mutable}
+    # target.
+    #
+    # @param statements [Enumerable, RDF::Statement] Some statements
+    # @return [self]
+    def delete(*statements)
+      process_statements(statements) do |stmts|
+        append_statements :deletes, stmts
+      end
+
+      self
     end
+    alias_method :delete!, :delete
+    alias_method :>>, :delete
+
+    private
 
-    # This simply returns its argument as a query in order to trick
-    # {RDF::Mutable#delete} into working.
-    def query(stmt)
-      RDF::Query.new RDF::Query::Pattern.from(stmt)
+    ##
+    # Append statements to the appropriate target. This is a crappy
+    # little shim to go in between the other shim and the target.
+    #
+    # @param target [Symbol] the method to send
+    # @param arg [Enumerable, RDF::Statement]
+    #
+    def append_statements(target, arg)
+      # coerce to an enumerator 
+      stmts = case
+              when arg.is_a?(RDF::Statement)
+                [arg]
+              when arg.respond_to?(:each_statement)
+                arg.each_statement
+              when arg.respond_to?(:each)
+                arg
+              else
+                raise ArgumentError, "Invalid statement: #{arg.class}"
+              end
+
+      stmts.each { |s| send(target) << s }
     end
 
-    undef_method :load, :update, :clear
   end # Changeset
 end # RDF

lib/rdf/mixin/mutable.rb

@@ -9,6 +9,7 @@ module Mutable
     extend  RDF::Util::Aliasing::LateBound
     include RDF::Readable
     include RDF::Writable
+    include RDF::Util::Coercions
 
     ##
     # Returns `true` if `self` is mutable.

lib/rdf/mixin/writable.rb

@@ -7,6 +7,7 @@ module RDF
   # @see RDF::Repository
   module Writable
     extend RDF::Util::Aliasing::LateBound
+    include RDF::Util::Coercions
 
     ##
     # Returns `true` if `self` is writable.
@@ -58,53 +59,13 @@ def <<(data)
     #   @param  [Enumerable<RDF::Statement>] statements
     #   @return [self]
     def insert(*statements)
-      process_statements(statements) { |value| insert_statements(value) }
+      process_statements(statements) { |value| insert_statements value }
 
       return self
     end
     alias_method :insert!, :insert
 
   protected
-
-  ##
-  # Coerce a set of arguments into {RDF::Statement} objects and then
-  # operate over them with a block.
-  # 
-  # @example
-  #  process_statements(statements) { |value| do_something(value) }
-  #
-  # @param statements [#map] The arbitrary-ish input to be manipulated
-  # @param query [false, true] Whether to call +query+ before the block
-  # @param constant [false, true] Whether to test if the statements
-  #  are constant
-  # @yield [RDF::Statement, RDF::Enumerable] 
-  # @return statements
-  def process_statements(statements, query: false, constant: false, &block)
-    raise ArgumentError, 'expecting a block' unless block_given?
-
-    statements = statements.map do |value|
-      case
-      when value.respond_to?(:each_statement)
-        block.call(value)
-        nil
-      when (statement = Statement.from(value)) &&
-          (!constant || statement.constant?)
-        statement
-      when query
-        block.call(query(value))
-        nil
-      else
-        raise ArgumentError, "Not a valid statement: #{value.inspect}"
-      end
-    end.compact
-
-    block.call(statements) unless statements.empty?
-
-    # eh might as well return these
-    statements
-  end
-
-
     ##
     # Inserts statements from the given RDF reader into the underlying
     # storage or output stream.

lib/rdf/util.rb

@@ -1,7 +1,8 @@
 module RDF; module Util
-  autoload :Aliasing, 'rdf/util/aliasing'
-  autoload :Cache,    'rdf/util/cache'
-  autoload :File,     'rdf/util/file'
-  autoload :Logger,   'rdf/util/logger'
-  autoload :UUID,     'rdf/util/uuid'
+  autoload :Aliasing,  'rdf/util/aliasing'
+  autoload :Cache,     'rdf/util/cache'
+  autoload :File,      'rdf/util/file'
+  autoload :Logger,    'rdf/util/logger'
+  autoload :UUID,      'rdf/util/uuid'
+  autoload :Coercions, 'rdf/util/coercions'
 end; end

lib/rdf/util/coercions.rb

@@ -0,0 +1,52 @@
+module RDF
+  module Util
+    module Coercions
+      # This is a provisional module intended to house input
+      # coercions. Currently the only coercion is a statement
+      # preprocessor that is used in e.g. {RDF::Writable#insert} and
+      # {RDF::Mutable#delete}.
+
+      ##
+      # Coerce a set of arguments into {RDF::Statement} objects and then
+      # operate over them with a block.
+      # 
+      # @example
+      #  process_statements(statements) { |value| do_something(value) }
+      #
+      # @param statements [#map] The arbitrary-ish input to be manipulated
+      # @param query [false, true] Whether to call +query+ before the block
+      # @param constant [false, true] Whether to test if the statements
+      #  are constant
+      # @yield [RDF::Statement, RDF::Enumerable] 
+      # @return statements
+      def process_statements(statements, query: false, constant: false, &block)
+        raise ArgumentError, 'expecting a block' unless block_given?
+
+        statements = statements.map do |value|
+          case
+          when value.respond_to?(:each_statement)
+            block.call(value)
+            nil
+          when (statement = Statement.from(value)) &&
+              (!constant || statement.constant?)
+            statement
+          when query
+            # XXX note that this only makes sense when the module is include()d
+            block.call(query(value))
+            nil
+          else
+            raise ArgumentError, "Not a valid statement: #{value.inspect}"
+          end
+        end.compact
+
+        block.call(statements) unless statements.empty?
+
+        # eh might as well return these
+        statements
+      end
+
+      # so you can include or call
+      extend self
+    end
+  end
+end

spec/changeset_spec.rb

@@ -28,7 +28,7 @@
   its(:deletes) { is_expected.to be_a(RDF::Enumerable) }
   its(:inserts) { is_expected.to be_a(RDF::Enumerable) }
 
-  it { is_expected.to be_mutable }
+  it { is_expected.to_not be_mutable }
   it { is_expected.to_not be_readable }
 
   it "does not respond to #load" do
@@ -135,4 +135,5 @@
         .to change { subject.inserts }.to contain_exactly(*statements)
     end
   end
+
 end