model_history 0.1.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.idea/
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+log/

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in model_history.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 patorash
+
+MIT License
+
+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.md

@@ -0,0 +1,57 @@
+# ModelHistory
+
+Model History is a simple gem that allows you to keep track of changes to specific fields in your Rails models using the ActiveRecord::Dirty module.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'model_history'
+
+Install it using Bundler:
+
+    $ bundle install
+
+Generate the Model History migration and migrate your database
+
+    $ rails generate model_history:migration
+    $ rake db:migrate
+
+## Usage
+
+```Ruby
+class Widget < ActiveRecord::Base
+  has_model_history :name, :price, :creator => proc{ User.current_user }
+  attr_accessible :name, :price
+end
+
+widget = Widget.last
+widget.name # => "Box"
+widget.name = "Heart Shaped Box"
+widget.save
+widget.model_history_records # => returns all changes to the widget
+  
+model_history = widget.model_history_records.last
+model_history.old_value # => "Box"
+model_history.new_value # => "Heart Shaped Box"
+
+user   = User.find(123)
+widget.model_history_records.created_by(user) 
+  # => returns all changes to the widget performed by the specified user
+
+class User < ActiveRecord::Base
+  creates_model_history
+end    
+
+user = User.find(123)
+user.model_history_records 
+  # => returns changes made by the specified user
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/generators/model_history/migration/migration_generator.rb

@@ -0,0 +1,31 @@
+require 'rails/generators/migration'
+
+module ModelHistory
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    desc "Generates migration for ModelHistoryRecord model"
+
+    def self.orm
+      Rails::Generators.options[:rails][:orm]
+    end
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'templates', (orm.to_s unless orm.class.eql?(String)) )
+    end
+
+    def self.orm_has_migration?
+      [:active_record].include? orm
+    end
+    
+    def self.next_migration_number(path)
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    end
+
+    def create_migration_file
+      if self.class.orm_has_migration?
+        migration_template 'migration.rb', 'db/migrate/create_model_history_records'
+      end
+    end
+  end
+end

data/lib/generators/model_history/migration/templates/active_record/migration.rb

@@ -0,0 +1,33 @@
+class CreateModelHistoryRecords < ActiveRecord::Migration
+  def self.up
+    create_table :model_history_records do |t|                                           
+      t.integer    :creator_id
+      t.string     :creator_type, :limit => 64
+      t.integer    :model_id
+      t.string     :model_type,  :limit => 64
+      t.string     :column_name,  :limit => 64
+      t.string     :column_type,  :limit => 16 # :string, :text, :integer, :decimal, :float, :datetime, :boolean
+      t.string     :old_value,    :limit => 128
+      t.string     :new_value,    :limit => 128
+    
+      t.datetime   :created_at
+      t.datetime   :revised_created_at
+      t.datetime   :updated_at
+      t.datetime   :deleted_at
+    end
+    add_index :model_history_records, [:creator_id, :creator_type]
+    add_index :model_history_records, [:model_id,  :model_type]
+    add_index :model_history_records, [:created_at,  :revised_created_at], :name => "index_created_at"
+    add_index :model_history_records, [:deleted_at, :created_at,  :revised_created_at], :name => "index_deleted_at_created_at"
+    add_index :model_history_records, [:model_type, :column_name, :deleted_at], :name => "index_obj_type_column_deleted_at"
+    add_index :model_history_records, [:model_type, :column_name, :deleted_at, :created_at, :revised_created_at], :name => "index_obj_type_column_deleted_at_created_at"
+
+    add_index :model_history_records, :old_value, :name => "index_old_value"
+    add_index :model_history_records, :new_value, :name => "index_new_value"
+    add_index :model_history_records, [:old_value, :new_value], :name => "index_old_value_new_value"
+  end
+
+  def self.down
+    drop_table :model_history_records
+  end
+end

data/lib/model_history.rb

@@ -0,0 +1,3 @@
+require "model_history/version"
+autoload :ModelHistoryRecord, 'model_history/model_history_record'
+require 'model_history/model_history_mixin'

data/lib/model_history/model_history_mixin.rb

@@ -0,0 +1,142 @@
+module ModelHistory
+   
+  module Mixin
+
+    class CreatorProcError < StandardError ; end
+    
+    def self.included base
+      base.class_eval do 
+        extend ClassMethods
+      end 
+    end       
+
+    module ClassMethods  
+      
+      # call the model_history class method on models with fields that you want to track changes on.
+      # example usage:
+      # class User < ActiveRecord::Base
+      #   has_model_history :email, :first_name, :last_name
+      # end
+
+      # pass an optional proc to assign a creator to the model_history object
+      # example usage:
+      # class User < ActiveRecord::Base
+      #   has_model_history :email, :first_name, :last_name, :creator => proc { User.current_user }
+      # end
+  
+      def has_model_history *args 
+        # Mix in the module, but ensure to do so just once.
+        metaclass = (class << self; self; end)
+        return if metaclass.included_modules.include?(ModelHistory::Mixin::ObjectInstanceMethods)
+
+        has_many        :model_history_records, :as => :model, :dependent => :destroy
+        attr_accessor   :model_history_changes, :initialize_model_history
+        cattr_accessor  :model_history_columns  
+
+
+        self.model_history_columns ||= []
+    
+        if args.present?
+          
+          before_save     :set_model_history_changes
+          after_save      :save_model_history
+
+          args.each do |arg| 
+            if [String,Symbol].include?(arg.class)     
+              arg = arg.to_sym
+              self.model_history_columns << arg unless self.model_history_columns.include?(arg)
+              define_method "creator_for_model_history" do end
+            elsif arg.is_a?(Hash)
+              creator_proc = arg.delete(:creator)
+              send :define_method, "creator_for_model_history" do
+                begin
+                  creator_proc.is_a?(Proc) ? creator_proc.call : nil
+                rescue
+                  raise ModelHistory::Mixin::CreatorProcError
+                end
+              end
+            end
+          end
+          include ModelHistory::Mixin::ObjectInstanceMethods
+        end
+      end # has_model_history
+  
+      def creates_model_history 
+        # Mix in the module, but ensure to do so just once.
+        metaclass = (class << self; self; end)
+        return if metaclass.included_modules.include?(ModelHistory::Mixin::CreatorInstanceMethods)
+      
+        has_many :model_history_records, :as => :creator
+        
+        include ModelHistory::Mixin::CreatorInstanceMethods
+      end # creates_model_history
+    end # ClassMethods
+
+    module ObjectInstanceMethods
+      
+      def set_model_history_changes                    
+        return true unless self.new_record? || self.changed? 
+        
+        self.model_history_changes    = self.class.model_history_columns.inject({}) do |changes_hash, column_name| 
+          changes_hash[column_name]   = self.send("#{column_name}_change") if self.send("#{column_name}_changed?")  
+          changes_hash[column_name] ||= [nil, self.send(column_name)] if self.new_record? && self.send(column_name).present?
+          changes_hash
+        end  
+
+        self.initialize_model_history = self.new_record?
+        true
+      end    
+      
+      def save_model_history     
+        return true unless self.model_history_changes.present?
+        self.model_history_changes.each do |column_name,vals|
+          add_model_history_record column_name, vals[0], vals[1], :creator => self.creator_for_model_history
+        end 
+        self.model_history_changes = nil
+        true
+      end
+      
+      def add_model_history_record column_name, old_value, new_value, options={}    
+        creator = options[:creator] || self.creator_for_model_history
+        
+        dhr_attributes = { 
+          :model       => self,
+          :column_name  => column_name,
+          :column_type  => self.class.columns_hash[column_name.to_s].type,
+          :old_value    => old_value,
+          :new_value    => new_value,
+          :creator      => creator
+        }  
+
+        dhr = ModelHistoryRecord.new(dhr_attributes)
+        
+        # attributes for manual updates
+        [:revised_created_at, :performing_manual_update].each do |attribute|
+          dhr.send("#{attribute}=", options[attribute]) if options[attribute]
+        end
+        
+        self.model_history_records << dhr
+      end
+
+      def history_for_column column, options={}
+        options[:sort] = true if options[:sort].blank?
+        
+        records = model_history_records.for_column(column)
+        records = records.send(*options[:scope]) if options[:scope]
+        records = records.order_asc if options[:sort]
+
+        options[:return_objects] ? records : records.map { |s| s.new_value }
+      end
+
+    end # ObjectInstanceMethods
+
+    module CreatorInstanceMethods
+  
+    end # CreatorInstanceMethods
+
+  end # Mixin
+  
+end # ModelHistory
+
+
+ActiveRecord::Base.send :include, ModelHistory::Mixin

data/lib/model_history/model_history_record.rb

@@ -0,0 +1,71 @@
+require "active_record"
+
+class ModelHistoryRecord < ActiveRecord::Base
+  belongs_to :creator,  :polymorphic => true
+  belongs_to :model,   :polymorphic => true
+
+  validates_presence_of :model_type, :model_id, :column_name, :column_type, :new_value
+
+  scope :created_by,            lambda { |creator| where(["#{table_name}.creator_id = ? AND #{table_name}.creator_type = ?", creator.id, creator.class.name]) }
+  scope :not_created_by,        lambda { |non_creator| where(["#{table_name}.creator_id <> ? OR #{table_name}.creator_type <> ?", non_creator.id, non_creator.class.name]) }
+  scope :for_model_type,        lambda { |model_type| where(model_type: model_type.to_s.classify) }
+  scope :for_column,            lambda { |column| where(column_name: column.to_s) }
+  scope :created_in_range,      lambda { |range| created_at_gte(range.first).created_at_lte(range.last) }
+  scope :created_at_gte,        lambda { |date| created_at_lte_or_gte(date,"gte") }
+  scope :created_at_lte,        lambda { |date| created_at_lte_or_gte(date,"lte") }
+  scope :created_at_lte_or_gte, lambda { |date, lte_or_gte| 
+    lte_or_gte = lte_or_gte.to_s == "lte" ? "<=" : ">="
+    where("((#{table_name}.revised_created_at is NULL OR #{table_name}.revised_created_at = '') AND #{table_name}.created_at #{lte_or_gte} ?) " + 
+          " OR #{table_name}.revised_created_at #{lte_or_gte} ?", date, date)
+  }
+
+  scope :order_asc, lambda { order_by_action_timestamp("ASC") }
+  scope :order_desc, lambda { order_by_action_timestamp("DESC") }
+  scope :order_by_action_timestamp, lambda { |asc_or_desc|
+    order("CASE WHEN (#{table_name}.revised_created_at IS NULL OR #{table_name}.revised_created_at = '') then #{table_name}.created_at else #{table_name}.revised_created_at END #{asc_or_desc}")
+  }
+
+
+  attr_accessible :model, :model_id, :model_type,
+                  :column_name, :column_type, :old_value, :new_value, 
+                  :creator, :creator_id, :creator_type, :revised_created_at
+
+  attr_accessor   :performing_manual_update
+
+
+  [:new_value, :old_value].each do |attribute|
+    define_method "#{attribute}" do 
+      val_to_col_type(attribute)
+    end
+    define_method "#{attribute}=" do |val|
+      self[attribute] = val.nil? ? nil : val.to_s
+      instance_variable_set "@#{attribute}", val
+    end
+  end       
+       
+  def action_timestamp                           
+    # use revised_created_at field to update the timestamp for
+    # the dirty history action while retaining data integrity
+    self[:revised_created_at] || self[:created_at]
+  end            
+  
+  private
+  
+  def val_to_col_type attribute
+    val_as_string = self[attribute]
+    return nil if val_as_string.nil?
+    case self[:column_type].to_sym
+    when :integer, :boolean
+      val_as_string.to_i
+    when :decimal, :float
+      val_as_string.to_f
+    when :datetime
+      Time.parse val_as_string
+    when :date
+      Date.parse val_as_string
+    else # :string, :text
+      val_as_string
+    end
+  end
+  
+end

data/lib/model_history/version.rb

@@ -0,0 +1,3 @@
+module ModelHistory
+  VERSION = "0.1.0"
+end

data/model_history.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'model_history/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'model_history'
+  spec.version       = ModelHistory::VERSION
+  spec.authors       = ['patorash']
+  spec.email         = ['chariderpato@gmail.com']
+  spec.description   = %q{Model History is a simple gem that allows you to keep track of changes to specific fields in your Rails models using the ActiveRecord::Dirty module.}
+  spec.summary       = %q{Model History is a simple gem that allows you to keep track of changes to specific fields in your Rails models using the ActiveRecord::Dirty module.}
+  spec.homepage      = 'https://github.com/patorash/model_history'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec-rails'
+  spec.add_development_dependency 'activerecord'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_dependency 'rails', '>= 3.2.11'
+end

data/spec/fake_app.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+require 'active_record'
+require 'action_controller/railtie'
+require 'action_view/helpers'
+require 'model_history'
+
+# database
+ActiveRecord::Base.configurations = {'test' => {:adapter => 'sqlite3', :database => ':memory:'}}
+ActiveRecord::Base.establish_connection('test')
+
+# config
+app = Class.new(Rails::Application)
+app.config.secret_token = '3b7cd727ee24e8444053437c36cc66c4'
+app.config.session_store :cookie_store, :key => '_myapp_session'
+app.config.active_support.deprecation = :log
+app.initialize!
+
+# routes
+app.routes.draw do
+  resources :users
+end
+
+# models
+class User < ActiveRecord::Base
+  has_model_history :name, :age
+  validates :name, :presence => true
+end
+
+# controllers
+class ApplicationController < ActionController::Base; end
+
+# helpers
+Object.const_set(:ApplicationHelper, Module.new)
+
+#migrations
+class CreateAllTables < ActiveRecord::Migration
+  def self.up
+    create_table(:users) {|t| t.string :name; t.integer :age}
+  end
+end

data/spec/models/user_spec.rb

@@ -0,0 +1,35 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe User do
+  describe "Check history" do
+    context "name change" do
+      before do
+        @user = User.create!(:name => 'Makunouchi', :age => 22)
+        @user.update_attributes!(:name => 'Sendo')
+      end
+      it "Get user history" do
+        history = @user.model_history_records.last
+        history.model_type.should == 'User'
+        history.column_name.should == 'name'
+        history.column_type.should == 'string'
+        history.old_value.should == 'Makunouchi'
+        history.new_value.should == 'Sendo'
+      end
+      it "#history_for_column" do
+        histories = @user.history_for_column :name
+        histories.should have(2).items
+        histories.should == ['Makunouchi', 'Sendo']
+      end
+    end
+
+    context "callback methods" do
+      it "call add_model_history_record" do
+        user = User.new(:name => "Makunouchi", :age => 22)
+        user.should_receive(:set_model_history_changes)
+        user.should_receive(:save_model_history)
+        user.save!
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+require File.join(File.dirname(__FILE__), 'fake_app')
+
+require 'rspec/rails'
+require 'generators/model_history/migration/templates/active_record/migration'
+
+RSpec.configure do |config|
+  config.before :all do
+    CreateAllTables.up unless ActiveRecord::Base.connection.table_exists? 'users'
+    CreateModelHistoryRecords.up unless ActiveRecord::Base.connection.table_exists? 'model_history_records'
+  end
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: model_history
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- patorash
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+description: Model History is a simple gem that allows you to keep track of changes
+  to specific fields in your Rails models using the ActiveRecord::Dirty module.
+email:
+- chariderpato@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/generators/model_history/migration/migration_generator.rb
+- lib/generators/model_history/migration/templates/active_record/migration.rb
+- lib/model_history.rb
+- lib/model_history/model_history_mixin.rb
+- lib/model_history/model_history_record.rb
+- lib/model_history/version.rb
+- model_history.gemspec
+- spec/fake_app.rb
+- spec/models/user_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/patorash/model_history
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1898891071957235163
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1898891071957235163
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Model History is a simple gem that allows you to keep track of changes to
+  specific fields in your Rails models using the ActiveRecord::Dirty module.
+test_files:
+- spec/fake_app.rb
+- spec/models/user_spec.rb
+- spec/spec_helper.rb