mongoid_simple_audit 0.1.4

data/lib/mongoid/simple_audit/simple_audit.rb

@@ -0,0 +1,113 @@
+# Use this macro if you want changes in your model to be saved in an audit table.
+# The audits table must exist.
+#
+#   class Booking
+#     simple_audit
+#   end
+#
+# See SimpleAudit::ClassMethods#simple_audit for configuration options
+
+module Mongoid
+
+  module SimpleAudit
+    module Model
+      extend ActiveSupport::Concern
+
+      def audit
+        Audit.find_by_auditable( self )
+      end
+
+
+      module ClassMethods
+
+        # == Configuration options
+        #
+        # * <tt>username_method => symbol</tt> - Call this method on the current user to get the name
+        #
+        # With no block, all the attributes and <tt>belongs_to</tt> associations (id and to_s) of the audited model will be logged.
+        #
+        #    class Booking
+        #      # this is equivalent to passing no block
+        #      simple_audit do |audited_record|
+        #        audited_record.attributes
+        #      end
+        #    end
+        #
+        # If a block is given, the data returned by the block will be saved in the audit's change log.
+        #
+        #    class Booking
+        #      has_many :housing_units
+        #      simple_audit do |audited_record|
+        #        {
+        #          :some_relevant_attribute => audited_record.some_relevant_attribute,
+        #          :human_readable_serialization_of_aggregated_models => audited_record.housing_units.collect(&:to_s),
+        #          ...
+        #        }
+        #      end
+        #    end
+        #
+
+        def simple_audit(options = {}, &block)
+          class_eval do
+
+            class_attribute :username_method
+            class_attribute :audit_changes
+            class_attribute :audit_changes_only
+
+            self.username_method = (options[:username_method] || :name).to_sym
+            self.audit_changes_only = options[:audit_changes_only] === true
+
+            attributes_and_associations = proc do |record|
+              changes = record.attributes
+              record.class.reflect_on_all_associations(:belongs_to).each do |assoc|
+                changes[assoc.name] = record.send(assoc.name).to_s
+              end
+              changes
+            end
+            audit_changes_proc = block_given? ? block.to_proc : attributes_and_associations
+            
+            self.audit_changes = audit_changes_proc
+            after_create {|record| record.class.audit(record, :create, nil)}
+            after_update {|record| record.class.audit(record, :update, nil)}
+          end
+        end
+
+        def audit(record, action = :update, user = nil) #:nodoc:
+          
+          record_audit = SimpleAudit::Audit.find_or_create_by_auditable( record )
+
+          # check current user for typical Authentication systems
+          user = nil
+          if defined?(User) and User.respond_to?(:current)
+            user = User.current 
+          elsif defined?(Cms::User) and Cms::User.respond_to?(:current)
+            user = Cms::User.current 
+          end
+
+          current_change_log = self.audit_changes.call(record)          
+
+          # do only log if anything changed
+          record_changed = true
+          if audit_changes_only and last_change_log = record.audit.modifications.last
+            record_changed = last_change_log.symbolized_change_log != current_change_log
+          end
+
+          if record_changed
+            if user.present?
+              record_audit.modifications.create(
+                :user => {id: user.id, type: user.class.name},
+                :username => user.try(self.username_method),
+                :action => action.to_s,
+                :change_log => current_change_log)
+            else
+              record_audit.modifications.create(
+                :action => action.to_s,
+                :change_log => current_change_log)
+            end
+          end
+
+        end
+      end  
+    end
+  end
+end

data/lib/mongoid/simple_audit/tasks.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__),'../../tasks/*.rake')].each { |f| load f }

data/lib/mongoid/simple_audit/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module SimpleAudit
+    VERSION = "0.1.4"
+  end
+end

data/lib/mongoid_simple_audit.rb

@@ -0,0 +1,17 @@
+require 'mongoid/simple_audit/simple_audit'
+require 'mongoid/simple_audit/audit'
+require 'mongoid/simple_audit/modification'
+require 'mongoid/simple_audit/helper'
+require File.dirname(__FILE__) + '/mongoid/simple_audit/railtie' if defined?(Rails::Railtie)
+
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.send :include, Mongoid::SimpleAudit::Model
+end
+
+if defined?(Mongoid::Document)
+  Mongoid::Document.send :include, Mongoid::SimpleAudit::Model
+end
+
+if defined?(ActionView::Base)
+  ActionView::Base.send :include, Mongoid::SimpleAudit::Helper
+end

data/lib/tasks/mongoid_simple_audit_migration.rake

@@ -0,0 +1,57 @@
+# rake mongoid_simple_audit:migrates_from_mysql_to_mongoid
+
+namespace :mongoid_simple_audit do
+  
+  desc "Migrates all datasets from simple audit ActiveRecord Gem into MongoDB"
+  task :migrates_from_mysql_to_mongoid => :environment do
+
+    # create ActiveRecord Version of Audit
+    ArAudit = Class.new(ActiveRecord::Base) do
+      belongs_to :auditable,  :polymorphic => true
+      belongs_to :user,       :polymorphic => true          
+      serialize  :change_log
+      self.table_name = 'audits'
+    end
+
+    total_count = ArAudit.count
+    new_audit = nil
+    current_count = 0
+    batch_size = 1000
+    offset = 0
+    puts "starting to migrate #{total_count} records."
+
+    loop do
+      break if offset > total_count
+
+      ArAudit.offset( offset ).limit( batch_size ).order( [:auditable_type, :auditable_id] ).each do |audit|
+
+        if new_audit.nil? || new_audit.auditable_id != audit.auditable_id || new_audit.auditable_type != audit.auditable_type
+          new_audit = Mongoid::SimpleAudit::Audit.find_or_create_by( {auditable_type: audit.auditable_type, auditable_id: audit.auditable_id} )
+        end
+
+        current_count += 1
+        if (current_count % batch_size == 0) || (total_count < batch_size)
+          puts "migrated #{current_count}. #{total_count-current_count} remaining"
+        end
+
+        begin
+          ds = {          
+            action: audit.action,
+            created_at: audit.created_at,
+            change_log: audit.change_log
+          }
+          if audit.user_id.present?
+            ds.merge!({
+              user: {id: audit.user_id, type: audit.user_type},
+              username: audit.username
+            })
+          end
+          new_audit.modifications.create( ds )
+        rescue Exception => e 
+          puts "could not copy audit with ID: #{audit.id} because: #{e.message}"
+        end
+      end # <- END: Find Audits
+      offset += batch_size
+    end # <- END: batch-loop
+  end
+end

data/mongoid_simple_audit.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongoid/simple_audit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mongoid_simple_audit"
+  spec.version       = Mongoid::SimpleAudit::VERSION
+  spec.authors       = ["Felix Abele"]
+  spec.email         = ["felix.abele@googlemail.com"]
+  spec.summary       = %q{Simple auditing solution for ActiveRecord models}
+  spec.description   = %q{Provides a straightforward way for auditing changes on active record models, especially for composite entities. Also provides helper methods for easily rendering an audit trail in Ruby on Rails views.}
+  spec.homepage      = "https://github.com/felixabele/mongoid_simple_audit.git"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")  
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib"]
+  
+  spec.add_dependency "mongoid"
+  spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "activerecord"  
+  spec.add_development_dependency "factory_girl_rails"  
+  spec.add_development_dependency "sqlite3"  
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-rails"
+  spec.add_development_dependency "coveralls", '~> 0.7.1'
+end

data/spec/factories.rb

@@ -0,0 +1,25 @@
+FactoryGirl.define do
+  
+  factory :address do
+    line_1  "John"
+    zip     "12047"
+  end
+
+  factory :person do
+    name  "Felix"
+    email "felix.abele@gmail.com"
+    address
+  end  
+
+  factory :user do
+    name  "Some user"
+  end  
+
+  factory :ar_audit, class: ArAudit do
+    association :auditable, :factory => :person
+    association :user, :factory => :user
+    action "some-action"
+    change_log( {'name' => 'Joe'} )
+  end    
+
+end

data/spec/helpers/simple_audit_helper_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'action_view'
+require 'active_support'
+
+include ActionView::Helpers::TagHelper
+include ActionView::Helpers::TranslationHelper
+include ActionView::Helpers::OutputSafetyHelper
+include ActionView::Context
+
+
+module Mongoid  
+
+  describe SimpleAudit::Helper do
+    
+    include SimpleAudit::Helper
+
+    it "should create an audit trail" do      
+      person = create(:person)      
+      expect( render_audits(person) ).to match person.name
+    end
+
+    it "should create mark differences between two change logs" do      
+      person = create(:person)
+      person.update_attribute :name, 'Franz'
+      expect( render_audits(person) ).to match("<span class=\"current\">Franz</span><span class=\"previous\">Felix</span>")
+    end    
+  end
+end

data/spec/lib/tasks/mongoid_simple_audit_rake_spec.rb

@@ -0,0 +1,28 @@
+# spec/lib/tasks/mongoid_simple_audit_rake_spec.rb
+require 'spec_helper'
+require 'rake'
+
+describe "mongoid_simple_audit:migrates_from_mysql_to_mongoid" do
+
+  before(:each) do
+    task_name = 'mongoid_simple_audit:migrates_from_mysql_to_mongoid'
+    task_path = "../lib/tasks/mongoid_simple_audit_migration"
+    rake = Rake::Application.new
+    Rake.application = rake
+    Rake.application.rake_require( task_path )
+    Rake::Task.define_task(:environment)
+    @subject = rake[task_name]
+  end
+
+  it "task should copy datasets from ActiveRecord to MongoDB" do        
+    person1 = create(:person)
+    person2 = create(:person)
+    2.times{ create :ar_audit, auditable: person1 }
+    4.times{ create :ar_audit, auditable: person2 }
+    @subject.invoke
+    expect( Mongoid::SimpleAudit::Audit.by_auditable(ArAudit.first.auditable).where('modifications.action' => 'some-action') ).to exist
+    expect( Mongoid::SimpleAudit::Audit.find_by_auditable( person1 ).modifications.count ).to be 3
+    expect( Mongoid::SimpleAudit::Audit.find_by_auditable( person2 ).modifications.count ).to be 5
+  end
+
+end

data/spec/models/simple_mongo_audit_spec.rb

@@ -0,0 +1,64 @@
+# spec/models/simple_mongo_audit_spec.rb
+require 'spec_helper'
+
+module Mongoid  
+
+  describe SimpleAudit::Audit do
+
+    it 'should create new Audit' do      
+      expect( SimpleAudit::Audit.new( auditable_type: 'SomeModel', auditable_id: 1).save ).to be true
+    end
+
+    it 'should create valid fixtures' do      
+      create :address
+      expect( Address.first ).not_to be_nil
+
+      create :person
+      expect( Person.first ).not_to be_nil      
+      expect( Person.first.address ).not_to be_nil      
+    end    
+
+    it 'should create a new audit record with initial modification record' do 
+      audit = SimpleAudit::Audit.find_or_create_by_auditable( create(:person) )
+      expect( audit ).not_to be_nil
+      expect( audit.modifications ).not_to be_empty
+    end
+
+    it "should set correct action" do
+      address = create :address
+      expect( address.audit.modifications.last.action ).to eql 'create'
+    end
+
+    it "should audit only given fields" do
+      person = create :person
+      person.update_attributes email: 'new@email.com', name: 'new name'
+      expect( person.audit.modifications.last.change_log ).not_to have_key( 'email' )      
+      expect( person.audit.modifications.last.change_log ).to have_key( 'name' )
+    end
+
+    it "should audit associated entity changes" do
+      person = create :person
+      expect( person.audit.modifications.last.change_log['address']['line_1'] ).to be_present
+    end
+
+    it "should not audit if no changes where made" do
+      person = create :person
+      person.update_attributes name: person.name
+      expect( person.audit.modifications.count ).to eql 1
+    end
+
+    it "should use proper username method" do 
+      address = HomeAddress.create
+      expect( User.new.short_name ).to eql address.audit.modifications.last.username
+
+      address = Address.create
+      expect( User.new.full_name ).to eql address.audit.modifications.last.username
+    end
+
+    it 'should audit Mongoid models' do 
+      address = MongoidAddress.create(name: 'Hans', street: 'Sesamstr. 18')
+      expect( address.audit.modifications ).not_to be_empty
+    end    
+  end
+
+end  

data/spec/spec_helper.rb

@@ -0,0 +1,125 @@
+require 'coveralls'
+Coveralls.wear!
+$:.unshift(File.join(File.dirname(__FILE__),'..','lib'))
+
+require 'mongoid'
+require 'rubygems'
+require 'active_record'
+require 'factory_girl_rails'
+require 'bundler'
+require 'mongoid_simple_audit'
+
+def database_id
+    ENV['CI'] ? "mongoid_simple_audit_#{Process.pid}" : 'mongoid_simple_audit_test'
+end
+
+Mongoid.configure do |config|
+  config.connect_to database_id
+end
+
+
+RSpec.configure do |c|
+
+  c.color = true
+  c.tty = true
+  c.formatter = :documentation  
+  c.include FactoryGirl::Syntax::Methods
+  
+  c.before(:each) do |example|
+    unless example.metadata[:keep_datasets]
+      Mongoid.purge!
+      Mongoid::IdentityMap.clear if defined?(Mongoid::IdentityMap)
+    end
+  end
+
+  c.after(:suite) do
+    Mongoid::Threaded.sessions[:default].drop if ENV['CI']
+  end
+end
+
+ActiveRecord::Base.establish_connection({
+  :adapter  => 'sqlite3',
+  :database => ':memory:'
+})
+
+ActiveRecord::Migration.suppress_messages {
+  ActiveRecord::Schema.define do
+    suppress_messages do
+      create_table "people", :force => true do |t|
+        t.column "name",  :text
+        t.column "email", :text
+      end
+      create_table "addresses", :force => true do |t|
+        t.column "line_1", :text
+        t.column "zip", :text
+        t.column "type", :text
+        t.references :person
+      end
+      create_table "users", :force => true do |t|
+        t.column "name", :text
+      end
+
+      # in order to test migration from ActiveRecord
+      create_table "audits", :force => true do |t|
+        t.belongs_to :auditable,  :polymorphic => true
+        t.belongs_to :user,       :polymorphic => true
+        t.string :username
+        t.string :action
+        t.text   :change_log
+        t.timestamps
+      end      
+    end
+  end
+}
+
+class Address < ActiveRecord::Base
+  belongs_to :person
+  simple_audit( username_method: :full_name )
+end
+
+class MongoidAddress  
+  include Mongoid::Document
+  include Mongoid::Attributes::Dynamic if Mongoid::VERSION.to_i > 3
+  simple_audit
+end
+
+class Person < ActiveRecord::Base
+  has_one :address
+  simple_audit( audit_changes_only: true ) do |record|
+    {
+      name: record.name,
+      address: { line_1: record.address.line_1, zip: record.address.zip }
+    }
+  end
+end
+
+class HomeAddress < Address
+  simple_audit :username_method => :short_name 
+end
+
+class ArAudit < ActiveRecord::Base
+  belongs_to :auditable,  :polymorphic => true
+  belongs_to :user,       :polymorphic => true    
+  serialize  :change_log
+  self.table_name = "audits"
+end
+
+class User < ActiveRecord::Base
+  def self.current; User.first ; end
+  
+  def name
+    "name"
+  end
+  
+  def full_name
+    "full_name"
+  end
+  
+  def short_name
+    "short_name"
+  end
+end
+
+require 'factories'
+
+User.create(:name => "some user")