track_changes 0.5.0 → 0.5.1

data/lib/track_changes/filter.rb

@@ -1,43 +1,43 @@
-require 'track_changes/result'
-
-module TrackChanges
-  class Filter
-    attr_accessor :call_proc, :changes, :model, :original
-
-    def initialize(model, yield_only_changed, call_proc)
-      @call_proc = call_proc
-      @model = model
-      @yield_only_changed = yield_only_changed
-      @changes = []
-      @original = []
-    end
-
-    def before(controller)
-      @original = clone_model(controller)
-    end
-
-    def after(controller)
-      cur_model = controller.instance_variable_get("@#{@model}")
-      # If changed? returns true, then the update didn't succeed.
-      unless cur_model.changed?
-        @changes = changes_between(@original, cur_model)
-        unless @yield_only_changed && @changes.empty?
-          @call_proc.call(Result.new(@model, controller, @changes))
-        end
-      end
-      nil
-    end
-
-    private
-
-    def changes_between(old, new)
-      old.attributes = new.attributes
-      old.changes
-    end
-
-    def clone_model(controller)
-      ivar = controller.instance_variable_get("@#{@model}")
-      ivar.clone if ivar.respond_to?(:clone)
-    end
-  end
-end
+require 'track_changes/result'
+
+module TrackChanges
+  class Filter
+    attr_accessor :call_proc, :changes, :model, :original
+
+    def initialize(model, yield_only_changed, call_proc)
+      @call_proc = call_proc
+      @model = model
+      @yield_only_changed = yield_only_changed
+      @changes = []
+      @original = []
+    end
+
+    def before(controller)
+      @original = clone_model(controller)
+    end
+
+    def after(controller)
+      cur_model = controller.instance_variable_get("@#{@model}")
+      # If changed? returns true, then the update didn't succeed.
+      unless cur_model.changed?
+        @changes = changes_between(@original, cur_model)
+        unless @yield_only_changed && @changes.empty?
+          @call_proc.call(Result.new(@model, controller, @changes))
+        end
+      end
+      nil
+    end
+
+    private
+
+    def changes_between(old, new)
+      old.attributes = new.attributes
+      old.changes
+    end
+
+    def clone_model(controller)
+      ivar = controller.instance_variable_get("@#{@model}")
+      ivar.clone if ivar.respond_to?(:clone)
+    end
+  end
+end

data/lib/track_changes/initializer.rb

@@ -1,18 +1,18 @@
-module TrackChanges
-  class Initializer
-    attr_accessor :configuration
-
-    include Singleton
-
-    class << self
-      alias_method :__tr_instance, :instance
-
-      def instance(&block)
-        obj = __tr_instance
-        obj.configuration ||= Configuration.new
-        yield obj.configuration if block_given?
-        obj
-      end
-    end
-  end
-end
+module TrackChanges
+  class Initializer
+    attr_accessor :configuration
+
+    include Singleton
+
+    class << self
+      alias_method :__tr_instance, :instance
+
+      def instance(&block)
+        obj = __tr_instance
+        obj.configuration ||= Configuration.new
+        yield obj.configuration if block_given?
+        obj
+      end
+    end
+  end
+end

data/lib/track_changes/instance_methods.rb

@@ -1,5 +1,5 @@
-module TrackChanges
-  module InstanceMethods
-    attr_accessor :track_changes_filter
-  end
-end
+module TrackChanges
+  module InstanceMethods
+    attr_accessor :track_changes_filter
+  end
+end

data/lib/track_changes/result.rb

@@ -1,36 +1,36 @@
-module TrackChanges
-  # A Result instance is yielded by ClassMethods#track_changes_to.
-  #
-  # Example:
-  #
-  #   track_changes_to :post do |result|
-  #     result.post         # => The instance variable in the current_controler
-  #                         #    given by the :post option.
-  #     result.controller   # => The instance of the current controller
-  #     result.current_user # => The current controllers @current_user
-  #     result.some_method  # => Call some_method on the current controller instance
-  #   end
-  class Result
-    attr_accessor :changes, :controller
-
-    def initialize(model_name, controller, changes)
-      @changes = changes
-      @controller = controller
-
-      self.class.send(:define_method, model_name) do
-        @controller.instance_variable_get("@#{model_name}")
-      end
-    end
-
-    # Pass all other methods to the controller.
-    def method_missing(method_sym, *args)
-      controller.send(method_sym, *args)
-    end
-
-    # A convienence method that returns the <tt>@current_user</tt>
-    # in the current controller.
-    def current_user
-      user = controller.instance_variable_get("@current_user")
-    end
-  end
-end
+module TrackChanges
+  # A Result instance is yielded by ClassMethods#track_changes_to.
+  #
+  # Example:
+  #
+  #   track_changes_to :post do |result|
+  #     result.post         # => The instance variable in the current_controler
+  #                         #    given by the :post option.
+  #     result.controller   # => The instance of the current controller
+  #     result.current_user # => The current controllers @current_user
+  #     result.some_method  # => Call some_method on the current controller instance
+  #   end
+  class Result
+    attr_accessor :changes, :controller
+
+    def initialize(model_name, controller, changes)
+      @changes = changes
+      @controller = controller
+
+      self.class.send(:define_method, model_name) do
+        @controller.instance_variable_get("@#{model_name}")
+      end
+    end
+
+    # Pass all other methods to the controller.
+    def method_missing(method_sym, *args)
+      controller.send(method_sym, *args)
+    end
+
+    # A convienence method that returns the <tt>@current_user</tt>
+    # in the current controller.
+    def current_user
+      user = controller.instance_variable_get("@current_user")
+    end
+  end
+end

data/lib/track_changes.rb

@@ -1,12 +1,12 @@
-require 'track_changes/result'
-require 'track_changes/configuration'
-require 'track_changes/initializer'
-require 'track_changes/audit_filter'
-require 'track_changes/filter'
-require 'track_changes/instance_methods'
-require 'track_changes/class_methods'
-require 'track_changes/base'
-
-module TrackChanges
-
-end
+require 'track_changes/result'
+require 'track_changes/configuration'
+require 'track_changes/initializer'
+require 'track_changes/audit_filter'
+require 'track_changes/filter'
+require 'track_changes/instance_methods'
+require 'track_changes/class_methods'
+require 'track_changes/base'
+
+module TrackChanges
+
+end

data/test/base_test.rb

@@ -1,20 +1,20 @@
-require 'test_helper'
-
-class BaseTest < Test::Unit::TestCase
-  context "when TrackChanges is included in a Class" do
-    setup do
-      class A
-        include TrackChanges
-      end
-    end
-
-    should "include InstanceMethods" do
-      assert A.included_modules.include?(TrackChanges::InstanceMethods)
-    end
-
-    should "extend class with ClassMethods" do
-      extended_modules = (class << A; self; end).included_modules
-      assert extended_modules.include?(TrackChanges::ClassMethods)
-    end
-  end
-end
+require 'test_helper'
+
+class BaseTest < Test::Unit::TestCase
+  context "when TrackChanges is included in a Class" do
+    setup do
+      class A
+        include TrackChanges
+      end
+    end
+
+    should "include InstanceMethods" do
+      assert A.included_modules.include?(TrackChanges::InstanceMethods)
+    end
+
+    should "extend class with ClassMethods" do
+      extended_modules = (class << A; self; end).included_modules
+      assert extended_modules.include?(TrackChanges::ClassMethods)
+    end
+  end
+end

data/test/class_methods_test.rb

@@ -1,29 +1,29 @@
-require 'test_helper'
-
-class ClassMethodsTest < Test::Unit::TestCase
-  include TrackChanges::ClassMethods
-
-  context "a ClassMethods module" do
-    context "when track_changes_to method called" do
-      setup { track_changes_to(:something) {} }
-
-      should "call append_before_filter" do
-        assert @before_filter
-      end
-
-      should "call append_after_filter" do
-        assert @after_filter
-      end
-    end
-  end
-
-  protected
-
-  def append_before_filter(options = {}, &block)
-    @before_filter = block
-  end
-
-  def append_after_filter(options = {}, &block)
-    @after_filter = block
-  end
-end
+require 'test_helper'
+
+class ClassMethodsTest < Test::Unit::TestCase
+  include TrackChanges::ClassMethods
+
+  context "a ClassMethods module" do
+    context "when track_changes_to method called" do
+      setup { track_changes_to(:something) {} }
+
+      should "call append_before_filter" do
+        assert @before_filter
+      end
+
+      should "call append_after_filter" do
+        assert @after_filter
+      end
+    end
+  end
+
+  protected
+
+  def append_before_filter(options = {}, &block)
+    @before_filter = block
+  end
+
+  def append_after_filter(options = {}, &block)
+    @after_filter = block
+  end
+end

data/test/filter_test.rb

@@ -1,73 +1,73 @@
-require 'test_helper'
-
-class FilterTest < Test::Unit::TestCase
-  context "a Filter instance" do
-    setup do
-      @controller = mock('@controller')
-      @model = mock('@model')
-      @proc_result = nil
-      @proc = Proc.new { |value| @proc_result = value }
-
-      @filter = TrackChanges::Filter.new(:model, true, @proc)
-    end
-
-    should "set @original when method before called" do
-      @model.expects(:clone).returns(mock('@model cloned', :my_mock? => true))
-      @controller.expects(:instance_variable_get).returns(@model)
-      @filter.before(@controller)
-
-      assert @filter.original.my_mock?
-    end
-
-    should "return a Result when after called" do
-      @filter.original = mock('original', :attributes= => {"attr" => "new"},
-                                          :changes => {"attr" => ["old", "new"]})
-      @new_model       = mock('new_model', :attributes => {"attr" => "new"},
-                                           :changed? => false)
-
-      @controller.expects(:instance_variable_get).once.returns(@new_model)
-
-      @filter.after(@controller)
-      assert @proc_result.is_a?(TrackChanges::Result)
-      assert_equal({"attr" => ["old", "new"]}, @proc_result.changes)
-    end
-
-    context "when yield_only_changed is true" do
-      setup do
-        @proc_result = nil
-        @filter = TrackChanges::Filter.new(:model, true, @proc)
-      end
-
-      should "not call block when method after called and changes is empty" do
-        @filter.original = mock('original', :attributes= => {"attr" => "new"},
-                                            :changes => {})
-        @new_model       = mock('new_model', :attributes => {"attr" => "new"},
-                                             :changed? => false)
-
-        @controller.expects(:instance_variable_get).once.returns(@new_model)
-
-        @filter.after(@controller)
-        assert_nil @proc_result
-      end
-    end
-
-    context "when yield_only_changed is false" do
-      setup do
-        @proc_result = nil
-        @filter = TrackChanges::Filter.new(:model, false, @proc)
-      end
-
-      should "call block when method after called and changes is empty" do
-        @filter.original = mock('original', :attributes= => {"attr" => "new"},
-                                            :changes => {})
-        @new_model       = mock('new_model', :attributes => {"attr" => "new"},
-                                             :changed? => false)
-
-        @controller.expects(:instance_variable_get).once.returns(@new_model)
-
-        @filter.after(@controller)
-        assert_not_nil @proc_result
-      end
-    end
-  end
-end
+require 'test_helper'
+
+class FilterTest < Test::Unit::TestCase
+  context "a Filter instance" do
+    setup do
+      @controller = mock('@controller')
+      @model = mock('@model')
+      @proc_result = nil
+      @proc = Proc.new { |value| @proc_result = value }
+
+      @filter = TrackChanges::Filter.new(:model, true, @proc)
+    end
+
+    should "set @original when method before called" do
+      @model.expects(:clone).returns(mock('@model cloned', :my_mock? => true))
+      @controller.expects(:instance_variable_get).returns(@model)
+      @filter.before(@controller)
+
+      assert @filter.original.my_mock?
+    end
+
+    should "return a Result when after called" do
+      @filter.original = mock('original', :attributes= => {"attr" => "new"},
+                                          :changes => {"attr" => ["old", "new"]})
+      @new_model       = mock('new_model', :attributes => {"attr" => "new"},
+                                           :changed? => false)
+
+      @controller.expects(:instance_variable_get).once.returns(@new_model)
+
+      @filter.after(@controller)
+      assert @proc_result.is_a?(TrackChanges::Result)
+      assert_equal({"attr" => ["old", "new"]}, @proc_result.changes)
+    end
+
+    context "when yield_only_changed is true" do
+      setup do
+        @proc_result = nil
+        @filter = TrackChanges::Filter.new(:model, true, @proc)
+      end
+
+      should "not call block when method after called and changes is empty" do
+        @filter.original = mock('original', :attributes= => {"attr" => "new"},
+                                            :changes => {})
+        @new_model       = mock('new_model', :attributes => {"attr" => "new"},
+                                             :changed? => false)
+
+        @controller.expects(:instance_variable_get).once.returns(@new_model)
+
+        @filter.after(@controller)
+        assert_nil @proc_result
+      end
+    end
+
+    context "when yield_only_changed is false" do
+      setup do
+        @proc_result = nil
+        @filter = TrackChanges::Filter.new(:model, false, @proc)
+      end
+
+      should "call block when method after called and changes is empty" do
+        @filter.original = mock('original', :attributes= => {"attr" => "new"},
+                                            :changes => {})
+        @new_model       = mock('new_model', :attributes => {"attr" => "new"},
+                                             :changed? => false)
+
+        @controller.expects(:instance_variable_get).once.returns(@new_model)
+
+        @filter.after(@controller)
+        assert_not_nil @proc_result
+      end
+    end
+  end
+end

data/test/functional/posts_controller_test.rb

@@ -1,16 +1,16 @@
-require 'test_helper'
-
-class PostsControllerTest < ActionController::TestCase
-  test "should update post" do
-    post = Post.create!(:title => "Hello, World", :body => "This is a test.", :author => "Matt Haley")
-    assert !post.new_record?
-
-    assert_difference("Audit.count") do
-      put :update, :id => post.to_param, :post => { :title => "First post!" }
-      assert_redirected_to post_path(assigns(:post))
-
-      audit = assigns(:post).audits.first
-      assert_equal ["Hello, World", "First post!"], audit.change_set["title"]
-    end
-  end
-end
+require 'test_helper'
+
+class PostsControllerTest < ActionController::TestCase
+  test "should update post" do
+    post = Post.create!(:title => "Hello, World", :body => "This is a test.", :author => "Matt Haley")
+    assert !post.new_record?
+
+    assert_difference("Audit.count") do
+      put :update, :id => post.to_param, :post => { :title => "First post!" }
+      assert_redirected_to post_path(assigns(:post))
+
+      audit = assigns(:post).audits.first
+      assert_equal ["Hello, World", "First post!"], audit.change_set["title"]
+    end
+  end
+end

data/test/rails_root/app/controllers/application_controller.rb

@@ -1,2 +1,2 @@
-class ApplicationController < ActionController::Base
-end
+class ApplicationController < ActionController::Base
+end

data/test/rails_root/app/controllers/posts_controller.rb

@@ -1,36 +1,36 @@
-require 'track_changes'
-
-class PostsController < ApplicationController
-  include TrackChanges
-  before_filter :find_post
-  track_changes :post, :only => :update
-
-  def show
-    render :text => @post.inspect
-  end
-
-  # PUT /posts/1
-  # PUT /posts/1.xml
-  def update
-    respond_to do |format|
-      if @post.update_attributes(params[:post])
-        flash[:notice] = 'Post was successfully updated.'
-        format.html { redirect_to(@post) }
-        format.xml  { head :ok }
-      else
-        format.html { render :action => "edit" }
-        format.xml  { render :xml => @post.errors, :status => :unprocessable_entity }
-      end
-    end
-  end
-
-  protected
-
-  def current_user
-    "John Smith"
-  end
-
-  def find_post
-    @post = Post.find(params[:id])
-  end
-end
+require 'track_changes'
+
+class PostsController < ApplicationController
+  include TrackChanges
+  before_filter :find_post
+  track_changes :post, :only => :update
+
+  def show
+    render :text => @post.inspect
+  end
+
+  # PUT /posts/1
+  # PUT /posts/1.xml
+  def update
+    respond_to do |format|
+      if @post.update_attributes(params[:post])
+        flash[:notice] = 'Post was successfully updated.'
+        format.html { redirect_to(@post) }
+        format.xml  { head :ok }
+      else
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @post.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  protected
+
+  def current_user
+    "John Smith"
+  end
+
+  def find_post
+    @post = Post.find(params[:id])
+  end
+end

data/test/rails_root/app/models/audit.rb

@@ -1,4 +1,4 @@
-class Audit < ActiveRecord::Base
-  belongs_to :audited, :polymorphic => true
-  serialize :change_set
-end
+class Audit < ActiveRecord::Base
+  belongs_to :audited, :polymorphic => true
+  serialize :change_set
+end

data/test/rails_root/app/models/post.rb

@@ -1,3 +1,3 @@
-class Post < ActiveRecord::Base
-  has_many :audits, :as => :audited
-end
+class Post < ActiveRecord::Base
+  has_many :audits, :as => :audited
+end