memento 0.3.7 → 0.4.0

data/.rbenv-version

@@ -1 +1 @@
-1.9.3-p0
+1.9.3-p194

data/CHANGES.md

@@ -1,6 +1,15 @@
 ### dev
 
-[full changelog](http://github.com/yolk/valvat/compare/v0.3.7...master)
+[full changelog](http://github.com/yolk/valvat/compare/v0.4.0...master)
+
+### 0.4.0 / 2012-10-29
+
+[full changelog](http://github.com/yolk/valvat/compare/v0.3.7...v0.4.0)
+
+* Memento is a Module now, not a Singleton: Use Memento directly and not Memento.instance
+* Memento module is threadsafe now
+* Changed main api: instead of Memento.memento() use Memento.watch() or Memento()
+* Some code cleanup
 
 ### 0.3.7 / 2012-08-13
 

data/README.rdoc

@@ -26,9 +26,9 @@ memento needs two tables in your database, one to store "sessions" (sets of stat
 
   script/generate memento_migration
   rake db:migrate
-  
+
 memento assumes you have a user-model. Every session is owned by a user.
-  
+
 == Configure your models
 
 Then you have to tell every model you want to undo actions on that it should be watched by memento:
@@ -42,13 +42,13 @@ This will tell memento to create snapshots of the model when an new instance is
 If you want memento to only take snapshots on specific actions:
 
   memento_changes :update, :destroy
-  
+
 This will take a snapshot only when an instance is updated or destroyed.
 
 By default memento will ignore changes to the :updated_at and :created_at attributes. You can add further attributes to ignore with the :ignore option:
 
   memento_changes :ignore => [:calculated_birthday, :friends_count]
-  
+
 This will ignore changes on the calculated_birthday and the firends_count-attributes. When memento saves a whole instance of your model before it is destroyed, those attributes will not be stored for later recovery. Only ignore attributes you can re-calculate from other data!
 
 == Action!
@@ -57,22 +57,22 @@ When you perform any of the configured actions on your model in isolation in you
 
   Person.create!(:name => "Blah")
   Memento::Session.count # => 0
-  
+
 You have to wrap every action block you want memento to track in your controller with the memento-method:
 
   memento do
     Person.create!(:name => "Blah")
   end
   Memento::Session.count # => 1
-  
-This assumes there is an method called "current_user" in your controllers. It will set the HTTP-Header 'X-Memento-Session-Id' on your response.
+
+This assumes there is an method called "current_user" in your controllers. It will also set the HTTP-Header 'X-Memento-Session-Id' on your response.
 
 If you want memento to watch changes outside of your controllers (for example inside the console) you can use:
 
-  Memento.instance.memento(user) do
+  Memento(user) do
     Person.create!(:name => "Blah")
   end
-  
+
 Where the variable user is assumed to hold an instance of User.
 
 == Undo!

data/generators/memento_migration/templates/migration.rb

@@ -1,11 +1,11 @@
 class MementoMigration < ActiveRecord::Migration
-  
+
   def self.up
     create_table :memento_sessions do |t|
       t.references :user
       t.timestamps
     end
-  
+
     create_table :memento_states do |t|
       t.string :action_type
       t.binary :record_data, :limit => 16777215
@@ -14,10 +14,10 @@ class MementoMigration < ActiveRecord::Migration
       t.timestamps
     end
   end
-  
+
   def self.down
     drop_table :memento_states
     drop_table :memento_sessions
   end
-  
+
 end

data/lib/memento.rb

@@ -1,63 +1,81 @@
 require 'active_record'
 
-class Memento
-  include Singleton
-  
+module Memento
+
   class ErrorOnRewind < StandardError;end
-  
-  def memento(user)
-    start(user)
-    yield
-    !@session.states.count.zero? && @session rescue false
-  ensure
-    stop
-  end
-  
-  def start(user_or_id)
-    user = user_or_id.is_a?(User) ? user_or_id : User.find_by_id(user_or_id)
-    @session = user ? Memento::Session.new(:user => user) : nil
-  end
-  
-  def stop
-    @session.destroy if @session && @session.states.count.zero?
-    @session = nil
-  end
-  
-  def add_state(action_type, record)
-    return unless save_session
-    @session.add_state(action_type, record)
-  end
-  
-  def active?
-    !!(defined?(@session) && @session) && !ignore?
-  end
-  
-  def ignore
-    @ignore = true
-    yield
-  ensure
-    @ignore = false
-  end
-  
-  def self.serializer=(serializer)
-    @serializer = serializer
-  end
-  
-  def self.serializer
-    @serializer ||= YAML
-  end
-  
-  private
-  
-  def ignore?
-    defined?(@ignore) && @ignore
-  end
-  
-  def save_session
-    active? && (!@session.changed? || @session.save)
+
+  class << self
+
+    # For backwards compatibility (was a Singleton)
+    def instance
+      self
+    end
+
+    def watch(user_or_id)
+      start(user_or_id)
+      yield
+      session && !session.new_record? && session.states.any? ? session : false
+    ensure
+      stop
+    end
+
+    def start(user_or_id)
+      user = user_or_id.is_a?(User) ? user_or_id : User.find_by_id(user_or_id)
+      self.session = user ? Memento::Session.new(:user => user) : nil
+    end
+
+    def stop
+      session.destroy if session && session.states.count.zero?
+      self.session = nil
+    end
+
+    def add_state(action_type, record)
+      return unless save_session
+      session.add_state(action_type, record)
+    end
+
+    def active?
+      !!session && !ignore?
+    end
+
+    def ignore
+      Thread.current[:memento_ignore] = true
+      yield
+    ensure
+      Thread.current[:memento_ignore] = false
+    end
+
+    def serializer=(serializer)
+      @serializer = serializer
+    end
+
+    def serializer
+      @serializer ||= YAML
+    end
+
+    private
+
+    def session
+      Thread.current[:memento_session]
+    end
+
+    def session=(session)
+      Thread.current[:memento_session] = session
+    end
+
+    def ignore?
+      !!Thread.current[:memento_ignore]
+    end
+
+    def save_session
+      active? && (!session.changed? || session.save)
+    end
   end
 end
 
+def Memento(user_or_id, &block)
+  Memento.watch(user_or_id, &block)
+end
 require 'memento/result'
 require 'memento/action'
 require 'memento/active_record_methods'

data/lib/memento/action.rb

@@ -5,29 +5,29 @@ module Memento::Action
     def initialize(state)
       @state = state
     end
-    
+
     attr_reader :state
     class_attribute :action_types, :instance_reader => false, :instance_writer => false
     self.action_types = []
-    
+
     def record
       @state.record
     end
-    
+
     def record_data
       @state.record_data
     end
-    
+
     def fetch?
       true
     end
-    
+
     def self.inherited(child)
       self.action_types << child.name.demodulize.underscore
     end
-    
+
     private
-    
+
     def new_object
       object = @state.record_type.constantize.new
       yield(object) if block_given?

data/lib/memento/action/create.rb

@@ -1,37 +1,39 @@
-class Memento::Action::Create < Memento::Action::Base
-  
-  def fetch;end
-  
-  def undo
-    if record.nil?
-      build_fake_object
-    elsif record_was_changed?
-      was_changed
-    else
-      destroy_record
+module Memento
+  class Action::Create < Memento::Action::Base
+
+    def fetch;end
+
+    def undo
+      if record.nil?
+        build_fake_object
+      elsif record_was_changed?
+        was_changed
+      else
+        destroy_record
+      end
     end
-  end
-  
-  private
-  
-  def record_was_changed?
-    record.updated_at > record.created_at rescue false
-  end
-  
-  def build_fake_object
-    new_object do |object|
-      object.id = state.record_id
+
+    private
+
+    def record_was_changed?
+      record.updated_at > record.created_at rescue false
     end
+
+    def build_fake_object
+      new_object do |object|
+        object.id = state.record_id
+      end
+    end
+
+    def was_changed
+      record.errors.add(:memento_undo, ActiveSupport::StringInquirer.new("was_changed"))
+      record
+    end
+
+    def destroy_record
+      record.destroy
+      record
+    end
+
   end
-  
-  def was_changed
-    record.errors.add(:memento_undo, ActiveSupport::StringInquirer.new("was_changed"))
-    record
-  end
-  
-  def destroy_record
-    record.destroy
-    record
-  end
-  
 end

data/lib/memento/action/destroy.rb

@@ -1,31 +1,32 @@
-class Memento::Action::Destroy < Memento::Action::Base
-  
-  def fetch
-    record.attributes_for_memento
-  end
-  
-  def undo
-    rebuild_object do |object|
-      begin
-        object.save!
-      rescue
-        object.id = nil
-        object.save!
+module Memento
+  class Action::Destroy < Memento::Action::Base
+
+    def fetch
+      record.attributes_for_memento
+    end
+
+    def undo
+      rebuild_object do |object|
+        begin
+          object.save!
+        rescue
+          object.id = nil
+          object.save!
+        end
+        state.record = object
+        state.save
       end
-      state.record = object
-      state.save
     end
-  end
-  
-  private
-  
-  def rebuild_object
-    new_object do |object|
-      state.record_data.each do |attribute, value|
-        object.send(:"#{attribute}=", value)
+
+    private
+
+    def rebuild_object
+      new_object do |object|
+        state.record_data.each do |attribute, value|
+          object.send(:"#{attribute}=", value)
+        end
+        yield(object) if block_given?
       end
-      yield(object) if block_given?
     end
   end
-  
 end

data/lib/memento/action/update.rb

@@ -1,54 +1,55 @@
-class Memento::Action::Update < Memento::Action::Base
-  
-  def fetch
-    record.changes_for_memento
-  end
-  
-  def fetch?
-    record.changes_for_memento.any?
-  end
-  
-  def undo
-    if !record
-      was_destroyed
-    elsif mergable?
-      update_record
-    else
-      was_changed
+module Memento
+  class Action::Update < Memento::Action::Base
+
+    def fetch
+      record.changes_for_memento
     end
-  end
-  
-  private
-  
-  def update_record
-    record.tap do |object|
-      record_data.each do |attribute, values|
-        object.send(:"#{attribute}=", values.first)
+
+    def fetch?
+      record.changes_for_memento.any?
+    end
+
+    def undo
+      if !record
+        was_destroyed
+      elsif mergable?
+        update_record
+      else
+        was_changed
       end
-      object.save!
     end
-  end
-  
-  def mergable?
-    record_data.all? do |attribute, values|
-      # ugly fix to compare times
-      values = values.map{|v| v.is_a?(Time) ? v.to_s(:db) : v }
-      current_value = record.send(:"#{attribute}")
-      current_value = current_value.utc.to_s(:db) if current_value.is_a?(Time)
-      values.include?(current_value) || (current_value.is_a?(String) && values.include?(current_value.gsub(/\r\n/, "\n")))
-    end || record_data.size.zero?
-  end
-  
-  def was_destroyed
-    new_object do |object|
-      object.errors[:memento_undo] << ActiveSupport::StringInquirer.new("was_destroyed")
-      object.id = state.record_id
+
+    private
+
+    def update_record
+      record.tap do |object|
+        record_data.each do |attribute, values|
+          object.send(:"#{attribute}=", values.first)
+        end
+        object.save!
+      end
+    end
+
+    def mergable?
+      record_data.all? do |attribute, values|
+        # ugly fix to compare times
+        values = values.map{|v| v.is_a?(Time) ? v.to_s(:db) : v }
+        current_value = record.send(:"#{attribute}")
+        current_value = current_value.utc.to_s(:db) if current_value.is_a?(Time)
+        values.include?(current_value) || (current_value.is_a?(String) && values.include?(current_value.gsub(/\r\n/, "\n")))
+      end || record_data.size.zero?
+    end
+
+    def was_destroyed
+      new_object do |object|
+        object.errors[:memento_undo] << ActiveSupport::StringInquirer.new("was_destroyed")
+        object.id = state.record_id
+      end
+    end
+
+    def was_changed
+      record.errors[:memento_undo] << ActiveSupport::StringInquirer.new("was_changed")
+      record
     end
   end
-  
-  def was_changed
-    record.errors[:memento_undo] << ActiveSupport::StringInquirer.new("was_changed")
-    record
-  end
-  
 end