save_queue 0.2.3 → 0.3.0

data/lib/save_queue/object.rb

@@ -1,39 +1,54 @@
-require "save_queue/queue"
-require 'active_support/core_ext/class/inheritable_attributes'
+require 'save_queue/object_queue'
 
 module SaveQueue
   module Object
-    #class_inheritable_accessor :queue_class
     def self.included base
       base.class_eval do
-        class_inheritable_accessor :queue_class
-        #class<<self
-        #  attr_accessor :queue_class
-        #end
 
-        self.queue_class ||= Queue
+        class<<self
+          attr_reader :queue_class
+
+          def queue_class=(klass)
+            raise "Your Queue implementation: #{klass} should include Hooks module!" unless klass.include? Hooks
+            @queue_class = klass
+          end
+        end
+
+        def self.inherited base
+          base.queue_class = self.queue_class
+        end
+
+        self.queue_class ||= ObjectQueue
       end
     end
 
+
     module RunAlwaysFirst
-      # @return [Boolean]
+      # can not reilly on save! here, because client may not define it at all
       def save(*args)
-        #return false if defined?(super) and false == super
+        super_result = true
+        super_result = super if defined?(super)
+
+        return false unless !!super_result
 
-        super_saved = true
-        super_saved = super if defined?(super)
-        # object is saved here
         mark_as_saved
-        return (super_saved and save_queue.save)
+        if save_queue.save
+          true == super_result ? true : super_result # super_result may be not boolean, String for ex
+        else
+          false
+        end
+      end
 
+      # Suppose,that save! raise an Exception if failed to save an object
+      def save!
+        super if defined?(super)
+        mark_as_saved
+        save_queue.save!
       end
     end
 
-
     def initialize(*args)
-      queue = self.class.queue_class.new
-      instance_variable_set "@_save_queue", queue
-
+      create_queue
       super if defined?(super)
 
       # this will make RunAlwaysFirst methods triggered first in inheritance tree
@@ -44,6 +59,7 @@ module SaveQueue
       instance_variable_set "@_changed_mark", true
     end
 
+    # @returns [Boolean] true if object has been modified
     def has_unsaved_changes?
       status = instance_variable_get("@_changed_mark")
       status.nil? ? false : status
@@ -56,5 +72,12 @@ module SaveQueue
     def mark_as_saved
       instance_variable_set "@_changed_mark", false
     end
+
+    private
+    def create_queue
+      klass = self.class.queue_class
+      queue = klass.new
+      instance_variable_set "@_save_queue", queue
+    end
   end
 end

data/lib/save_queue/object_queue.rb

@@ -0,0 +1,87 @@
+require 'forwardable'
+# TODO remove hooks or extract to a module
+require 'hooks'
+require 'save_queue/uniq_queue'
+
+module SaveQueue
+  class ObjectQueue < UniqQueue
+    include Hooks
+
+    define_hook :before_save
+    # triggered only after successful save
+    define_hook :after_save
+
+    define_hook :before_add
+    define_hook :after_add
+
+    # @return [Hash] save
+    # @option save [Array<Object>] :processed
+    # @option save [Array<Object>] :saved
+    # @option save [Object]        :failed
+    # @option save [Array<Object>] :pending
+    attr_reader :errors
+    def initialize(*args)
+      super
+      @errors = {}
+    end
+
+    def add object
+      run_hook :before_add
+
+      check_requirements_for object
+      result = super object
+
+      run_hook :after_add, result, object
+
+      result
+    end
+
+    def << object
+      add object
+      self
+    end
+
+    alias_method :push, :add
+
+    def save
+      save!
+      true
+    rescue SaveQueue::Error
+      false
+    end
+
+    def save!
+      run_hook :before_save
+      @errors = {}
+      saved     = []
+      processed = []
+
+      @queue.each do |object|
+        if object.has_unsaved_changes?
+
+          result = object.save
+          if false == result
+            @errors[:save] = {:processed => processed, :saved => saved, :failed => object, :pending => @queue - (saved + [object])}
+            raise FailedSaveError, errors[:save]
+          end
+
+          saved << object
+        end
+        processed << object
+      end
+
+      @queue.clear
+
+      run_hook :after_save
+      true
+    end
+
+
+    private
+    def check_requirements_for object
+      [:save, :has_unsaved_changes?].each do |method|
+        raise ArgumentError, "#{object.inspect} does not respond to ##{method}" unless object.respond_to? method
+      end
+    end
+  end
+end

data/lib/save_queue/plugins/notification/object.rb

@@ -0,0 +1,35 @@
+module SaveQueue
+  module Plugins
+    module Notification
+      module Object
+        module AddObserverToQueue
+          def create_queue
+            super
+            queue = instance_variable_get("@_save_queue")
+            raise "save queue should respond to add_observer in order to work correctly" unless queue.respond_to? :add_observer
+            queue.add_observer(self, :queue_changed_event)
+          end
+        end
+        
+        def self.included base
+
+          #queue_creator = Module.new do
+          #  def create_queue
+          #    super
+          #    queue = instance_variable_get("@_save_queue")
+          #    raise "save queue should respond to add_observer in order to work correctly" unless queue.respond_to? :add_observer
+          #    queue.add_observer(self, :queue_changed_event)
+          #  end
+          #end
+
+          #base.send :include, queue_creator
+          base.send :include, AddObserverToQueue unless base.include?(AddObserverToQueue)
+        end
+
+        def queue_changed_event(result, object)
+          mark_as_changed if result
+        end
+      end
+    end
+  end
+end

data/lib/save_queue/plugins/notification/queue.rb

@@ -0,0 +1,25 @@
+if RUBY_VERSION < "1.9"
+  require "save_queue/ruby1.9/observer"
+else
+  require 'observer'
+end
+
+module SaveQueue
+  module Plugins
+    module Notification
+      module Queue
+        def self.included base
+          base.send :include, Observable unless base.include? Observable
+          base.after_add :change_and_notify # if base.respond_to? :after_add
+        end
+
+        private
+        def change_and_notify(*args)
+          changed
+          notify_observers(*args)
+        end
+
+      end
+    end
+  end
+end

data/lib/save_queue/plugins/notification.rb

@@ -0,0 +1,15 @@
+require "save_queue/plugins/notification/queue"
+require "save_queue/plugins/notification/object"
+
+module SaveQueue
+  module Plugins
+    module Notification
+      def self.included base
+        klass = Class.new(base.queue_class)
+        klass.send :include, Notification::Queue unless klass.include? Notification::Queue
+        base.send :include, Notification::Object unless base.include? Notification::Object
+        base.queue_class = klass
+      end
+    end
+  end
+end

data/lib/save_queue/plugins/validation/exceptions.rb

@@ -0,0 +1,12 @@
+module SaveQueue
+  class FailedValidationError < Error
+    attr_reader :failed_objects
+    def initialize(failed_objects)
+      @failed_objects = Array(failed_objects)
+    end
+
+    def to_s # Some default way to display errors
+      "#{super}: " + @failed_objects.map{|object| "\"#{object.to_s}\": " + object.errors.full_messages.join(', ')}.join("\n")
+    end
+  end
+end

data/lib/save_queue/plugins/validation/queue.rb

@@ -1,33 +1,32 @@
-require "save_queue/queue"
+require "save_queue/plugins/validation/exceptions"
+
 module SaveQueue
   module Plugins
     module Validation
-      class Queue < ::SaveQueue::Queue
-        attr_reader :objects_with_errors
-
-        def initialize(*args)
-          @objects_with_errors = []
-          super
+      module Queue
+        def self.included base
+          base.before_save :validate! if base.respond_to? :before_save
         end
 
         def valid?
-          @objects_with_errors = []
+          validate
+        end
+
+        def validate
           @queue.each do |object|
-            @objects_with_errors << object unless object.valid?
+            unless object.valid?
+              @errors[:validation] ||= []
+              @errors[:validation].push(object)
+            end
           end
-
-          @objects_with_errors.empty?
+          
+          @errors.empty?
         end
 
         def validate!
-          raise FailedValidationError, @objects_with_errors unless valid?
-
+          raise FailedValidationError, @errors[:validation] unless valid?
           true
         end
-
-        def errors
-          @objects_with_errors.map(&:errors).reduce(:+)
-        end
       end
     end
   end

data/lib/save_queue/plugins/validation.rb

@@ -1,27 +1,14 @@
-require "save_queue/queue"
-
-require "save_queue/plugins/validation/object"
 require "save_queue/plugins/validation/queue"
+require "save_queue/plugins/validation/exceptions"
 
 
 module SaveQueue
   module Plugins
     module Validation
       def self.included base
-        # must be included after SaveQueue::Object
-        base.send :include, Validation::Object
-        base.queue_class = Validation::Queue
-      end
-
-      class FailedValidationError < RuntimeError
-        attr_reader :failed_objects
-        def initialize(failed_objects)
-          @failed_objects = Array(failed_objects)
-        end
-
-        def to_s # Some default way to display errors
-          "#{super}: " + @failed_objects.map{|object| "\"#{object.to_s}\": " + object.errors.full_messages.join(', ')}.join("\n")
-        end
+        klass = Class.new(base.queue_class)
+        klass.send :include, Validation::Queue
+        base.queue_class = klass
       end
     end
   end

data/lib/save_queue/ruby1.9/observer.rb

@@ -0,0 +1,204 @@
+module SaveQueue
+#
+# Implementation of the _Observer_ object-oriented design pattern.  The
+# following documentation is copied, with modifications, from "Programming
+# Ruby", by Hunt and Thomas; http://www.rubycentral.com/book/lib_patterns.html.
+#
+# See Observable for more info.
+
+# The Observer pattern (also known as publish/subscribe) provides a simple
+# mechanism for one object to inform a set of interested third-party objects
+# when its state changes.
+#
+# == Mechanism
+#
+# The notifying class mixes in the +Observable+
+# module, which provides the methods for managing the associated observer
+# objects.
+#
+# The observers must implement a method called +update+ to receive
+# notifications.
+#
+# The observable object must:
+# * assert that it has +#changed+
+# * call +#notify_observers+
+#
+# === Example
+#
+# The following example demonstrates this nicely.  A +Ticker+, when run,
+# continually receives the stock +Price+ for its <tt>@symbol</tt>.  A +Warner+
+# is a general observer of the price, and two warners are demonstrated, a
+# +WarnLow+ and a +WarnHigh+, which print a warning if the price is below or
+# above their set limits, respectively.
+#
+# The +update+ callback allows the warners to run without being explicitly
+# called.  The system is set up with the +Ticker+ and several observers, and the
+# observers do their duty without the top-level code having to interfere.
+#
+# Note that the contract between publisher and subscriber (observable and
+# observer) is not declared or enforced.  The +Ticker+ publishes a time and a
+# price, and the warners receive that.  But if you don't ensure that your
+# contracts are correct, nothing else can warn you.
+#
+#   require "observer"
+#
+#   class Ticker          ### Periodically fetch a stock price.
+#     include Observable
+#
+#     def initialize(symbol)
+#       @symbol = symbol
+#     end
+#
+#     def run
+#       lastPrice = nil
+#       loop do
+#         price = Price.fetch(@symbol)
+#         print "Current price: #{price}\n"
+#         if price != lastPrice
+#           changed                 # notify observers
+#           lastPrice = price
+#           notify_observers(Time.now, price)
+#         end
+#         sleep 1
+#       end
+#     end
+#   end
+#
+#   class Price           ### A mock class to fetch a stock price (60 - 140).
+#     def Price.fetch(symbol)
+#       60 + rand(80)
+#     end
+#   end
+#
+#   class Warner          ### An abstract observer of Ticker objects.
+#     def initialize(ticker, limit)
+#       @limit = limit
+#       ticker.add_observer(self)
+#     end
+#   end
+#
+#   class WarnLow < Warner
+#     def update(time, price)       # callback for observer
+#       if price < @limit
+#         print "--- #{time.to_s}: Price below #@limit: #{price}\n"
+#       end
+#     end
+#   end
+#
+#   class WarnHigh < Warner
+#     def update(time, price)       # callback for observer
+#       if price > @limit
+#         print "+++ #{time.to_s}: Price above #@limit: #{price}\n"
+#       end
+#     end
+#   end
+#
+#   ticker = Ticker.new("MSFT")
+#   WarnLow.new(ticker, 80)
+#   WarnHigh.new(ticker, 120)
+#   ticker.run
+#
+# Produces:
+#
+#   Current price: 83
+#   Current price: 75
+#   --- Sun Jun 09 00:10:25 CDT 2002: Price below 80: 75
+#   Current price: 90
+#   Current price: 134
+#   +++ Sun Jun 09 00:10:25 CDT 2002: Price above 120: 134
+#   Current price: 134
+#   Current price: 112
+#   Current price: 79
+#   --- Sun Jun 09 00:10:25 CDT 2002: Price below 80: 79
+module Observable
+
+  #
+  # Add +observer+ as an observer on this object. so that it will receive
+  # notifications.
+  #
+  # +observer+:: the object that will be notified of changes.
+  # +func+:: Symbol naming the method that will be called when this Observable
+  #          has changes.
+  #
+  #          This method must return true for +observer.respond_to?+ and will
+  #          receive <tt>*arg</tt> when #notify_observers is called, where
+  #          <tt>*arg</tt> is the value passed to #notify_observers by this
+  #          Observable
+  def add_observer(observer, func=:update)
+    @observer_peers = {} unless defined? @observer_peers
+    unless observer.respond_to? func
+      raise NoMethodError, "observer does not respond to `#{func.to_s}'"
+    end
+    @observer_peers[observer] = func
+  end
+
+  #
+  # Remove +observer+ as an observer on this object so that it will no longer
+  # receive notifications.
+  #
+  # +observer+:: An observer of this Observable
+  def delete_observer(observer)
+    @observer_peers.delete observer if defined? @observer_peers
+  end
+
+  #
+  # Remove all observers associated with this object.
+  #
+  def delete_observers
+    @observer_peers.clear if defined? @observer_peers
+  end
+
+  #
+  # Return the number of observers associated with this object.
+  #
+  def count_observers
+    if defined? @observer_peers
+      @observer_peers.size
+    else
+      0
+    end
+  end
+
+  #
+  # Set the changed state of this object.  Notifications will be sent only if
+  # the changed +state+ is +true+.
+  #
+  # +state+:: Boolean indicating the changed state of this Observable.
+  #
+  def changed(state=true)
+    @observer_state = state
+  end
+
+  #
+  # Returns true if this object's state has been changed since the last
+  # #notify_observers call.
+  #
+  def changed?
+    if defined? @observer_state and @observer_state
+      true
+    else
+      false
+    end
+  end
+
+  #
+  # Notify observers of a change in state *if* this object's changed state is
+  # +true+.
+  #
+  # This will invoke the method named in #add_observer, pasing <tt>*arg</tt>.
+  # The changed state is then set to +false+.
+  #
+  # <tt>*arg</tt>:: Any arguments to pass to the observers.
+  def notify_observers(*arg)
+    if defined? @observer_state and @observer_state
+      if defined? @observer_peers
+        @observer_peers.each do |k, v|
+          k.send v, *arg
+        end
+      end
+      @observer_state = false
+    end
+  end
+
+end
+end

data/lib/save_queue/uniq_queue.rb

@@ -0,0 +1,38 @@
+require 'forwardable'
+module SaveQueue
+  class UniqQueue
+    extend ::Forwardable
+    DELEGATED_METHODS = [:empty?,
+                         :any?,
+                         :size,
+                         :count,
+                         :clear,
+                         :inspect,
+                         :to_s,
+                         :first,
+                         :last,
+                         :pop,
+                         :shift]
+
+    def_delegators :@queue, *DELEGATED_METHODS
+    
+    def initialize
+      @queue = []
+    end
+
+    def add_all objects
+      Array(objects).each do |object|
+        add object
+      end
+    end
+
+    def add object
+      return false if @queue.include? object
+      @queue << object
+
+      true
+    end
+    alias_method :push, :add
+    alias_method :<<,   :add
+  end
+end

data/lib/save_queue/version.rb

@@ -1,3 +1,3 @@
 module SaveQueue
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

data/lib/save_queue.rb

@@ -1,5 +1,6 @@
 require "save_queue/version"
 require "save_queue/object"
+require "save_queue/exceptions"
 
 module SaveQueue
   def self.included base

data/save_queue.gemspec

@@ -8,8 +8,9 @@ Gem::Specification.new do |s|
   s.authors     = ["Alexander Paramonov"]
   s.email       = ["alexander.n.paramonov@gmail.com"]
   s.homepage    = "http://github.com/AlexParamonov/save_queue"
-  s.summary     = %q{Push related objects to a queue for delayed save}
-  s.description = %q{Save Queue allows to push related objects to an object's queue for delayed save, that will triggered on object#save. In this case object wil store all related information on its save.}
+  s.summary     = %q{Push related objects to a queue for a delayed save}
+  s.description = %q{Save Queue allows to push objects to other object's queue for a delayed save.
+Queue save will be triggered by object#save.}
 
   s.rubyforge_project = "save_queue"
 
@@ -21,5 +22,5 @@ Gem::Specification.new do |s|
   # specify any dependencies here; for example:
   s.add_development_dependency "rspec", ">= 2.6"
   s.add_development_dependency "rake"
-  s.add_runtime_dependency "activesupport"
+  s.add_runtime_dependency "hooks"
 end

data/spec/notification/notification_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+require "save_queue/plugins/notification"
+
+describe SaveQueue::Plugins::Notification do
+  describe "#integration" do
+    it "should mix Queue to object's save_queue" do
+      klass = new_class
+      klass.send :include, SaveQueue::Plugins::Notification
+
+      klass.queue_class.should include SaveQueue::Plugins::Notification::Queue
+    end
+
+    it "should not change original SaveQueue::*Queue class" do
+      klass = new_class
+      old_queue = klass.queue_class
+      klass.queue_class = Class.new(old_queue)
+
+      klass.send :include, SaveQueue::Plugins::Notification
+      old_queue.should_not include SaveQueue::Plugins::Notification::Queue
+    end
+
+    it "should mix Object to object class" do
+      klass = new_class
+      klass.send :include, SaveQueue::Plugins::Notification
+
+      klass.should include SaveQueue::Plugins::Notification::Object
+    end
+  end
+
+  describe "workflow" do
+    let(:object) do
+      klass = new_class
+      klass.send :include, SaveQueue::Plugins::Notification
+      klass.new
+    end
+
+    [:add, :<<, :push].each do |method|
+      it "should mark object as changed if save_queue was changed by ##{method}" do
+        object.mark_as_saved
+        object.save_queue.send method, new_object
+        object.should have_unsaved_changes
+      end
+    end
+  end
+end