tamaudit 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 803deb0c93b4f7f8396d2c975b23def4389011c3
+  data.tar.gz: fe511e53d190731f17d7a60a844bdcd341085eca
+SHA512:
+  metadata.gz: 76180c393d507d6b02eeed2e7bac52597d2e35d9d7e5266867d1ade0fdc77b8d39e3dfa53253ea00bf0a03843a925958dc34b975dabbc6a244b6956002c22730
+  data.tar.gz: 09a34a28dc8fbe14422d074cb5c97f9fac0ea9368b5f3e26ed377e30fc0b5d0c4ba6eb19c7629533bcd80f566a3e099bc3e149eb8f70f1cbb2572db74a2049de

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 continuum.cl
+
+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 @@
+# Tamaudit - IN PROGRESS
+
+## Audits activerecord models like a boss
+
+
+Audit activerecord models like a boss. Tested in rails 4 and ruby 2.0.0.
+
+This project is heavily based in Espinita gem (https://github.com/continuum/espinita).
+
+
+
+## Installation
+
+In your gemfile
+
+    gem "tamaudit"
+
+In console
+
+    $ rake tamaudit:install:migrations
+    $ rake db:migrate
+
+## Usage
+
+    class Post < ActiveRecord::Base
+      auditable
+    end
+
+    @post.create(title: "an awesome blog post" )
+
+Tamaudit will create an audit by default on creation , edition and destroy:
+
+    @post.audits.size #=> 1
+
+Tamaudit provides options to include or exclude columns to trigger the creation of audit.
+
+    class Post < ActiveRecord::Base
+      auditable only: [:title] # except: [:some_column]
+    end
+
+And lets you declare the callbacks you want for audit creation:
+
+    class Post < ActiveRecord::Base
+      auditable on: [:create]  # on: [:create, :update]
+    end
+
+You can find the audits records easily:
+
+    @post.audits.first #=>  #<Tamaudit::Audit id: 1, auditable_id: 1, auditable_type: "Post", user_id: 1, user_type: "User", audited_changes: {"title"=>[nil, "MyString"], "created_at"=>[nil, 2013-10-30 15:50:14 UTC], "updated_at"=>[nil, 2013-10-30 15:50:14 UTC], "id"=>[nil, 1]}
+
+Tamaudit will save the model changes in a serialized column called audited_changes:
+
+    @post.audits.first.audited_changes #=> {"title"=>[nil, "MyString"], "created_at"=>[nil, 2013-10-30 15:50:14 UTC], "updated_at"=>[nil, 2013-10-30 15:50:14 UTC], "id"=>[nil, 1]}
+
+Tamaudit will detect the current user when records saved from rails controllers. By default Tamaudit uses current_user method but you can change it:
+
+    Tamaudit.current_user_method = :authenticated_user

data/Rakefile

@@ -0,0 +1,31 @@
+#begin
+#  require 'bundler/setup'
+#rescue LoadError
+#  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+#end
+
+
+require 'rspec/core/rake_task'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+desc 'Default: run unit specs.'
+task :default => :spec
+
+desc 'Test the lazy_high_charts plugin.'
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.pattern = FileList['spec/**/*_spec.rb']
+end
+
+require 'rdoc/task'
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Tamaudit'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+#APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+#load 'rails/tasks/engine.rake'
+

data/app/models/tamaudit/audit.rb

@@ -0,0 +1,44 @@
+module Tamaudit
+  class Audit < ActiveRecord::Base
+
+    self.table_name = 'audits'
+
+    belongs_to :auditable, polymorphic: true
+    belongs_to :user, polymorphic: true
+
+
+    scope :descending,    ->{ reorder("version DESC")}
+    scope :creates,       ->{ where({:action => 'create'})}
+    scope :updates,       ->{ where({:action => 'update'})}
+    scope :destroys,      ->{ where({:action => 'destroy'})}
+
+    scope :up_until,      ->(date_or_time){where("created_at <= ?", date_or_time) }
+    scope :from_version,  ->(version){where(['version >= ?', version]) }
+    scope :to_version,    ->(version){where(['version <= ?', version]) }
+    scope :auditable_finder, ->(auditable_id, auditable_type){where(auditable_id: auditable_id, auditable_type: auditable_type)}
+
+    serialize :audited_changes
+
+    before_create :set_version_number, :set_audit_user
+
+    # Return all audits older than the current one.
+    def ancestors
+      self.class.where(['auditable_id = ? and auditable_type = ? and version <= ?',
+        auditable_id, auditable_type, version])
+    end
+
+  private
+    def set_version_number
+      max = self.class.auditable_finder(auditable_id, auditable_type).maximum(:version) || 0
+      self.version = max + 1
+    end
+
+    def set_audit_user
+      self.user           = RequestStore.store[:audited_user] if RequestStore.store[:audited_user]
+      self.remote_address = RequestStore.store[:audited_ip]   if RequestStore.store[:audited_ip]
+
+      nil # prevent stopping callback chains
+    end
+
+  end
+end

data/config/database.yml

@@ -0,0 +1,24 @@
+sqlite3mem: &SQLITE3MEM
+  adapter: sqlite3
+  database: ":memory:"
+
+sqlite3: &SQLITE
+  adapter: sqlite3
+  database: audited_test.sqlite3.db
+
+postgresql: &POSTGRES
+  adapter: postgresql
+  username: postgres
+  password: postgres
+  database: audited_test
+  min_messages: ERROR
+
+mysql: &MYSQL
+  adapter: mysql
+  host: localhost
+  username: root
+  password:
+  database: audited_test
+
+test:
+  <<: *<%= ENV['DB'] || 'SQLITE3MEM' %>

data/config/routes.rb

@@ -0,0 +1,2 @@
+Tamaudit::Engine.routes.draw do
+end

data/db/migrate/20131029200927_create_auditable_audits.rb

@@ -0,0 +1,14 @@
+class CreateAuditableAudits < ActiveRecord::Migration
+  def change
+    create_table :audits do |t|
+      t.references :auditable, polymorphic: true, index: true
+      t.references :user, polymorphic: true, index: true
+      t.text :audited_changes
+      t.string :comment
+      t.integer :version
+      t.string :action
+      t.string :remote_address
+      t.timestamps
+    end
+  end
+end

data/lib/tamaudit.rb

@@ -0,0 +1,20 @@
+require "tamaudit/engine"
+require "request_store"
+
+module Tamaudit
+
+  autoload :Auditor, "tamaudit/auditor"
+  autoload :AuditorBehavior, "tamaudit/auditor_behavior"
+  autoload :AuditorRequest, "tamaudit/auditor_request"
+
+  class << self
+
+    attr_accessor :current_user_method
+   
+    def current_user_method
+      @current_user_method ||= :current_user
+    end
+
+  end
+
+end

data/lib/tamaudit/auditor.rb

@@ -0,0 +1,7 @@
+module Tamaudit
+  module Auditor 
+    extend ActiveSupport::Concern
+    include Tamaudit::AuditorBehavior
+  end
+end
+

data/lib/tamaudit/auditor_behavior.rb

@@ -0,0 +1,98 @@
+module Tamaudit
+  module AuditorBehavior
+    extend ActiveSupport::Concern
+
+    included do 
+      class_attribute  :excluded_cols
+      class_attribute  :audit_callbacks
+      attr_accessor :audit_comment
+    end
+
+    module ClassMethods
+
+      @@default_excluded = %w(lock_version created_at updated_at created_on updated_on)
+
+      def auditable(options = {})
+
+        self.audit_callbacks = []
+        self.audit_callbacks << options[:on] unless options[:on].blank?
+        self.audit_callbacks.flatten!
+
+        after_create   :audit_create  if self.audit_callbacks.blank? || self.audit_callbacks.include?(:create)
+        before_update  :audit_update  if self.audit_callbacks.blank? || self.audit_callbacks.include?(:update)
+        before_destroy :audit_destroy if self.audit_callbacks.blank? || self.audit_callbacks.include?(:destroy)
+          
+        self.excluded_cols   = (@@default_excluded)
+
+        if options[:only]
+          options[:only] = [options[:only]].flatten.map { |x| x.to_s }
+          self.excluded_cols = (self.column_names - options[:only] ) 
+        end
+
+        if options[:except]
+          options[:except] = [options[:except]].flatten.map { |x| x.to_s }
+          self.excluded_cols = (@@default_excluded) + options[:except]
+        end
+
+        has_many :audits, :as => :auditable, :class_name => Tamaudit::Audit.name
+        #attr_accessor :audited_user, :audited_ip
+        accepts_nested_attributes_for :audits
+
+      end
+
+      def permited_columns
+        self.column_names - self.excluded_cols.to_a
+      end
+
+      # All audits made during the block called will be recorded as made
+      # by +user+. This method is hopefully threadsafe, making it ideal
+      # for background operations that require audit information.
+      def as_user(user, &block)
+        RequestStore.store[:audited_user] = user
+        yield
+      ensure
+        RequestStore.store[:audited_user] = nil
+      end
+
+    end
+
+    # audited attributes detected against permited columns
+    def audited_attributes
+      self.changes.keys & self.class.permited_columns
+    end
+
+    def audited_hash
+      Hash[ audited_attributes.map{|o| [o.to_sym, self.changes[o.to_sym] ] } ]
+    end
+
+
+    def audit_create
+      #puts self.class.audit_callbacks
+      write_audit(:action => 'create', 
+                  :audited_changes => audited_hash,
+                  :comment => audit_comment)
+    end
+
+    def audit_update
+      #puts self.class.audit_callbacks
+      write_audit(:action => 'update', 
+                  :audited_changes => audited_hash,
+                  :comment => audit_comment)
+    end
+
+    def audit_destroy
+      write_audit(:action => 'destroy', 
+                  :audited_changes => audited_hash,
+                  :comment => audit_comment)
+    end
+
+    def write_audit(options)
+      if options[:action] == 'destroy'
+        self.audits.create(options)
+      else
+        self.audits.create(options) unless audited_hash.blank?
+      end
+    end
+
+  end
+end

data/lib/tamaudit/auditor_request.rb

@@ -0,0 +1,13 @@
+module Tamaudit::AuditorRequest
+  extend ActiveSupport::Concern
+
+  included do 
+    before_filter :store_audited_user
+  end
+
+  def store_audited_user
+    RequestStore.store[:audited_user] = self.send(Tamaudit.current_user_method) #current_user
+    
+    RequestStore.store[:audited_ip]   = self.try(:request).try(:remote_ip)
+  end
+end

data/lib/tamaudit/engine.rb

@@ -0,0 +1,19 @@
+module Tamaudit
+  class Engine < ::Rails::Engine
+    isolate_namespace Tamaudit
+    
+    config.generators do |g|
+      g.test_framework  :rspec,
+                        :fixture_replacement => :factory_girl ,
+                        :dir => "spec/factories"
+      g.integration_tool :rspec
+    end
+
+    initializer "include Auditor request into action controller" do |app|
+      ActionController::Base.send(:include, Tamaudit::AuditorRequest)
+      ActiveRecord::Base.send(:include, Tamaudit::Auditor)
+    end
+
+
+  end
+end

data/lib/tamaudit/version.rb

@@ -0,0 +1,3 @@
+module Tamaudit
+  VERSION = "0.0.2"
+end

data/lib/tasks/tamaudit_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :tamaudit do
+#   # Task goes here
+# end

data/spec/controllers/audits_controller_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+class AuditsController < ActionController::Base
+  def audit
+    @general_model = FactoryGirl.create(:general_model)
+    render :nothing => true
+  end
+
+  def update_user
+    current_user.update_attributes( :password => 'foo')
+    render :nothing => true
+  end
+
+  private
+
+  attr_accessor :current_user
+  attr_accessor :custom_user
+end
+
+
+describe AuditsController do
+
+  before :each do 
+    GeneralModel.auditable
+  end
+
+  let( :general_model ){
+    FactoryFirl.create(:general_model)
+  }
+
+  let( :user ) { FactoryGirl.create(:user) }
+
+  describe "POST audit" do
+
+    it "should audit user" do
+      controller.send(:current_user=, user)
+      expect {
+        post :audit
+      }.to change( Tamaudit::Audit, :count )
+
+      assigns(:general_model).audits.last.user.should == user
+      assigns(:general_model).audits.last.remote_address.should == "0.0.0.0"
+
+    end
+  end
+
+end

data/spec/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.