gregfitz23-historic 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Greg Fitzgerald
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,32 @@
+= historic
+
+A gem for tracking changes of a model in a history table.  
+Allows fields to be marked as trigger fields that will initiate a copy of the record back to the history table.
+The history table rows will be created with the data as it existed before the current modifications were made.
+
+Usage (on the object to create history for):
+=begin 
+	acts_as_historic :on_change_of=>:field_1, :after => :some_method
+=end
+
+Usage (on the history object):
+=begin
+	acts_as_historic_record
+=end
+
+By default, the History Record object is assumed to be the name of the main object plus History so:
+For an object Foo, the History Record would be in a table called FooHistory.
+This can be overridden using the class_name option:
+=begin
+	acts_as_historic :class_name=>"BarHistory"
+=end
+
+Options:
+	* :on_change_of  - A list of fields to monitor for change.  When any of these fields changes, a history row is created.
+	* :on_initialize - Create a History Record indicating the initial creation of the main object.
+	* :class_name    - Specify a different History Record class name.
+	* :after         - A symbol or proc to be called on completion of the history row being created.
+
+== Copyright
+
+Copyright (c) 2009 Greg Fitzgerald. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "historic"
+    gem.summary = %Q{TODO}
+    gem.email = "greg_fitz@yahoo.com"
+    gem.homepage = "http://github.com/gregfitz23/historic"
+    gem.authors = ["Greg Fitzgerald"]
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test' << 'active_record'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "historic #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 0
+:patch: 1

data/lib/historic.rb

@@ -0,0 +1,3 @@
+require File.join(File.dirname(__FILE__), 'historic', 'historic')
+require File.join(File.dirname(__FILE__), 'historic', 'historic_record')
+require "acts_as_list"

data/lib/historic/historic.rb

@@ -0,0 +1,85 @@
+module ActiveRecord
+  module Acts
+    module Historic
+  
+      def self.append_features(base) #:nodoc:
+        super
+        base.extend(Definition)  
+      end
+      
+      module Definition
+        # Sets up before_save and before_destroy to create HistoricRecord rows when appropriate.
+        def acts_as_historic(options={})
+          extend ActiveRecord::Acts::Historic::ClassMethods          
+          include ActiveRecord::Acts::Historic::InstanceMethods
+          
+          historic_extract_options(options)
+          
+          alias_method_chain :before_save, :historic
+          alias_method_chain :before_destroy, :historic
+        end        
+      end
+      
+      module ClassMethods
+
+        def historic_table_class
+          @historic_table_class
+        end
+
+        def historic_options
+          @historic_options
+        end
+        
+        
+        private
+        # Extract the table class to be used or default to this class name + History.
+        # Ensure that on_change_of is an array.
+        #
+        def historic_extract_options(options)
+          @historic_table_class = (options.delete(:class_name) || "#{self.to_s}History").constantize  
+          
+          options[:on_change_of] = [options[:on_change_of]] if options[:on_change_of] && !options[:on_change_of].is_a?(Array)
+          @historic_options = options 
+        end
+        
+      end #ClassMethods
+      
+      module InstanceMethods
+        # Chain historic_copy_to_history into before_save.
+        # This will only be triggered if:
+        #   a. The current record is a new record OR the on_initialize flag is true
+        #   b. AND on_change_of is not nil AND one of the fields specified in on_change_of has changed
+        def before_save_with_historic
+          before_save_without_historic
+          
+          if historic_should_move_to_history?(historic_options)
+            historic_copy_to_history
+          end
+        end
+        
+        # Chain historic_copy_to_history into before_destroy.
+        #
+        def before_destroy_with_historic
+          before_destroy_without_historic
+          historic_copy_to_history
+        end
+          
+        private
+        def historic_should_move_to_history?(options)
+          (options[:on_initialize] || !new_record?) && (options[:on_change_of] && options[:on_change_of].any? {|field| self.__send__("#{field}_changed?")})
+        end  
+
+        # Copy the current item to the HistoryRecord object and execute the :after hook, if it exists
+        #        
+        def historic_copy_to_history
+          self.class.historic_table_class.__send__("create_history_from_current!", self)
+          historic_options[:after].to_proc.call(self) if historic_options[:after]
+        end
+        
+        def historic_options
+          self.class.historic_options
+        end
+      end #InstanceMethods      
+    end #Historic
+  end
+end

data/lib/historic/historic_record.rb

@@ -0,0 +1,47 @@
+module ActiveRecord
+  module Acts    
+    module HistoricRecord
+      def self.append_features(base)
+        super
+        base.extend(Definition)
+      end
+      
+      module Definition
+        def acts_as_historic_record
+          extend ClassMethods
+          acts_as_list
+        end        
+      end
+      
+      module ClassMethods
+        
+        # Same as create_history_from_current! but swallows exceptions and returns false.
+        def create_history_from_current(current)
+          create_history_from_current!(current) rescue false
+        end
+
+        # Create an HistoricRecord record based off of the passed in Object.
+        # Copy any fields that are on both the Object and the HistoricRecord object, preserving any changed values.
+        #
+        def create_history_from_current!(current)
+          history_obj = self.new
+          attrs_to_copy = current.attributes.reject {|key, value| !history_obj.attribute_names.include?(key)}
+
+          changed_attrs_with_old_values = {}
+          current.changes.each_pair {|field, value_ary| changed_attrs_with_old_values[field] = value_ary[0]}
+
+          attrs_to_copy.merge!(changed_attrs_with_old_values)
+          self.create(attrs_to_copy)
+        end        
+      end
+        
+    end #HistoricRecord
+  end #Acts
+end #ActiveRecord
+
+ActiveRecord::Base.class_eval do
+  include ActiveRecord::Acts::Historic
+  include ActiveRecord::Acts::HistoricRecord
+end
+    
+      

data/test/historic_item.rb

@@ -0,0 +1,8 @@
+class HistoricItem < ActiveRecord::Base
+
+  acts_as_historic :on_change_of=>:field_1, :after => :clear_field_3
+
+  def clear_field_3
+    self.field_3 = nil
+  end
+end

data/test/historic_item_history.rb

@@ -0,0 +1,5 @@
+class HistoricItemHistory < ActiveRecord::Base
+  
+  acts_as_historic_record
+  
+end

data/test/historic_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+
+class HistoricTest < Test::Unit::TestCase
+  context "A HistoryItem, @item" do
+    setup do
+      HistoricItemHistory.delete_all
+      HistoricItem.delete_all
+      
+      @item = HistoricItem.new
+      @item.field_1, @item.field_2, @item.field_3 = 1, 2, 3
+      @item.save!
+    end
+
+    should "not create a HistoryRecord when newly created" do
+      assert !HistoricItemHistory.exists?(:field_1=>"1", :field_2=>"2", :field_3=>"3")
+    end
+
+    context "and a new value for :field_1" do
+      setup do
+        @new_field_1 = "4"
+      end
+
+      context "when changing the value of :field_1 to @new_field_1" do
+        setup do
+          @old_item = @item.clone
+          @item.update_attributes(:field_1 => @new_field_1)
+        end
+
+        should "create a new ItemGuideHistory for the old item guide and item" do
+          assert HistoricItemHistory.exists?({:field_1=>@old_item.field_1, :field_2=>@old_item.field_2, :field_3=>@old_item.field_3})
+        end
+
+        context ", the HistoricItemHistory" do
+          setup do
+            @item_history = HistoricItemHistory.find_by_field_1_and_field_2_and_field_3(@old_item.field_1, @old_item.field_2, @old_item.field_3)
+          end
+
+          should "copy a from the HistoricItem" do
+            assert_equal @old_item.field_1, @item_history.field_1.to_i
+          end
+
+          should "copy b from the HistoricItem" do
+            assert_equal @old_item.field_2, @item_history.field_2.to_i
+          end
+
+          should "copy c from the HistoricItem" do
+            assert_equal @old_item.field_3, @item_history.field_3.to_i
+          end
+
+          should "clear c on the original HistoryItem" do
+            assert_equal nil, @item.field_3
+          end
+        end #for the HistoricItemHistory
+      end #when changing field_1 of HistoricIte
+    end #when changing the value of :field_1 to @new_field_1
+
+    context "passed to create_from_history_item" do
+      setup do
+        @item_history = HistoricItemHistory.create_history_from_current(@item)
+      end
+
+      should "copy a from the HistoricItem" do
+        assert_equal @item.field_1, @item_history.field_1
+      end
+
+      should "copy b from the HistoricItem" do
+        assert_equal @item.field_2, @item_history.field_2
+      end
+
+      should "copy c from the HistoricItem" do
+        assert_equal @item.field_3, @item_history.field_3
+      end
+
+    end #passed to create_history_from_current
+
+    context "when destroyed" do
+      setup do
+        assert_equal 0, HistoricItemHistory.count
+        @item.destroy
+      end
+
+      should "create an HistoricItemHistory row" do
+        assert_equal 1, HistoricItemHistory.count
+        # assert HistoricItemHistory.exists?({:field_1=>@item.field_1, :field_2=>@item.field_2, :field_3=>@item.field_3})
+      end
+    end #when destroyed
+  end # An item guide
+end

data/test/test_helper.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require "active_record"
+require 'historic'
+
+class Test::Unit::TestCase
+  
+  
+  ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+
+  ActiveRecord::Schema.define(:version => 1) do
+    columns = [:field_1, :field_2, :field_3]
+    create_table :historic_items do |t|
+      t.string *columns
+    end
+    
+    create_table :historic_item_histories do |t|
+      t.string *columns
+      t.integer :position
+    end
+  end
+  
+  require "historic_item_history"
+  require "historic_item"
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: gregfitz23-historic
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Greg Fitzgerald
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-11 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: greg_fitz@yahoo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- lib/historic.rb
+- lib/historic/historic.rb
+- lib/historic/historic_record.rb
+- test/historic_item.rb
+- test/historic_item_history.rb
+- test/historic_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/gregfitz23/historic
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: 
+- test/historic_item.rb
+- test/historic_item_history.rb
+- test/historic_test.rb
+- test/test_helper.rb