sequel_audited 0.2.0

data/Rakefile

@@ -0,0 +1,33 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+# 
+# 
+OSX = RUBY_PLATFORM.match(/darwin/)
+
+
+
+Rake::TestTask.new(:spec) do |t|
+  t.libs << 'spec'
+  t.libs << 'lib'
+  t.test_files = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+
+desc 'Run specs with coverage'
+task :coverage do
+  ENV['COVERAGE'] = '1'
+  Rake::Task['spec'].invoke
+  `open coverage/index.html` if OSX
+end
+
+desc 'Run Rubocop report'
+task :rubocop do
+  res = `which rubocop`
+  if res != ""
+    `rubocop -f html -o ./rubocop/report.html lib/`
+    `open rubocop/report.html` if OSX
+  else
+    puts "\nERROR: 'rubocop' gem is not installed or available. Please run 'gem install rubocop'."
+  end
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sequel/audited"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/env.test.sample

@@ -0,0 +1,7 @@
+# NOTE: rename this file as '.env.test' and change YOURNAME or the full DB path(s) below
+
+# Using PostgreSQL
+DATABASE_URL="postgres://YOURNAME@localhost/sequel-audited-test"
+
+# Using SQLite
+# DATABASE_URL="sqlite://spec/sequel-audited-test.db"

data/lib/sequel/audited.rb

@@ -0,0 +1,33 @@
+require 'sequel'
+require 'sequel/audited/version'
+
+module Sequel
+
+  #
+  module Audited
+
+    CREATE  = 'create'
+    UPDATE  = 'update'
+    DESTROY = 'destroy'
+
+    # set the name of the global method that provides the current user. Default: :current_user
+    @audited_current_user_method      = :current_user
+    # enable swapping of the Audit model
+    @audited_model_name               = :AuditLog
+    # toggle for enabling / disabling auditing
+    @audited_enabled                  = true
+
+    # by default ignore these columns
+    @audited_default_ignored_columns  = [
+      # :id, :ref, :password, :password_hash,
+      :lock_version,
+      :created_at, :updated_at, :created_on, :updated_on
+    ]
+
+    class << self
+      attr_accessor :audited_current_user_method, :audited_model_name,
+                    :audited_enabled, :audited_default_ignored_columns
+    end
+
+  end
+end

data/lib/sequel/audited/version.rb

@@ -0,0 +1,11 @@
+
+#
+module Sequel
+
+  #
+  module Audited
+
+    VERSION = '0.2.0'
+
+  end
+end

data/lib/sequel/plugins/audited.rb

@@ -0,0 +1,293 @@
+class AuditLog < Sequel::Model
+  # handle versioning of audited records
+  plugin :list, field: :version, scope: [:associated_type, :associated_id]
+  plugin :timestamps
+  plugin :serialization, :json, :changed
+  plugin :polymorphic
+
+  # TODO: see if we should add these
+  many_to_one :associated, polymorphic: true
+  many_to_one :modifier,   polymorphic: true
+
+  def before_validation
+    # grab the current user
+    if u = audit_user
+      self.modifier = u
+    end
+
+    super
+  end
+
+  # private
+
+  # Obtains the `current_user` based upon the `:audited_current_user_method' value set in the
+  # audited model, either via defaults or via :user_method config options
+  #
+  # # NOTE! this allows overriding the default value on a per audited model
+  def audit_user
+    m = Kernel.const_get(associated_type)
+    m.send(m.audited_current_user_method) || send(m.audited_current_user_method)
+  end
+
+end
+
+module Sequel
+  module Plugins
+
+    # Given a Post model with these fields:
+    #   [:id, :category_id, :title, :body, :author_id, :created_at, :updated_at]
+    #
+    #
+    # All fields
+    #   plugin :audited
+    #     #=> [:category_id, :title, :body, :author_id]  # NB! excluding @default_ignore_attrs
+    #     #=> [:id, :created_at, :updated_at]
+    #
+    # Single field
+    #   plugin :audited, only: :title
+    #   plugin :audited, only: [:title]
+    #     #=> [:title]
+    #     #+> [:id, :category_id, :body, :author_id, :created_at, :updated_at] # ignored fields
+    #
+    # Multiple fields
+    #   plugin :audited, only: [:title, :body]
+    #     #=> [:title, :body] # tracked fields
+    #     #=> [:id, :category_id, :author_id, :created_at, :updated_at] # ignored fields
+    #
+    #
+    # All fields except certain fields
+    #   plugin :audited, except: :title
+    #   plugin :audited, except: [:title]
+    #     #=> [:id, :category_id, :author_id, :created_at, :updated_at] # tracked fields
+    #     #=> [:title] # ignored fields
+    #
+    #
+    #
+    module Audited
+
+      # called when
+      def self.configure(model, opts = {})
+        model.instance_eval do
+          # add support for :dirty attributes tracking & JSON serializing of data
+          plugin(:dirty)
+          plugin(:json_serializer)
+          plugin(:polymorphic)
+
+          # set the default ignored columns or revert to defaults
+          set_default_ignored_columns(opts)
+          # sets the name of the current User method or revert to default: :current_user
+          # specifically for the audited model on a per model basis
+          set_user_method(opts)
+
+          set_reference_method(opts)
+
+          only    = opts.fetch(:only, [])
+          except  = opts.fetch(:except, [])
+
+          unless only.empty?
+            # we should only track the provided column
+            included_columns = [only].flatten
+            # subtract the 'only' columns from all columns to get excluded_columns
+            excluded_columns = columns - included_columns
+          else # except:
+            # all columns minus any excepted columns and default ignored columns
+            included_columns = [
+              [columns - [except].flatten].flatten - @audited_default_ignored_columns
+            ].flatten.uniq
+
+            # except_columns = except.empty? ? [] : [except].flatten
+            excluded_columns = [columns - included_columns].flatten.uniq
+            # excluded_columns = [columns - [except_columns, included_columns].flatten].flatten.uniq
+          end
+
+          @audited_included_columns = included_columns
+          @audited_ignored_columns  = excluded_columns
+
+          # each included model will have an associated versions
+          one_to_many(
+            :versions,
+            class: audit_model_name,
+            as: 'associated'
+          )
+
+        end
+
+
+      end
+
+      #
+      module ClassMethods
+
+        attr_accessor :audited_default_ignored_columns, :audited_current_user_method
+        # The holder of ignored columns
+        attr_reader :audited_ignored_columns
+        # The holder of columns that should be audited
+        attr_reader :audited_included_columns
+
+        attr_accessor :audited_reference_method
+
+
+        Plugins.inherited_instance_variables(self,
+                                             :@audited_default_ignored_columns => nil,
+                                             :@audited_current_user_method     => nil,
+                                             :@audited_included_columns        => nil,
+                                             :@audited_ignored_columns         => nil,
+                                             :@audited_reference_method        => nil
+                                            )
+
+        def non_audited_columns
+          columns - audited_columns
+        end
+
+        def audited_columns
+          @audited_columns ||= columns - @audited_ignored_columns
+        end
+
+        # def default_ignored_attrs
+        #   # TODO: how to reference the models primary_key value??
+        #   arr = [pk.to_s]
+        #   # handle STI (Class Table Inheritance) models with `plugin :single_table_inheritance`
+        #   arr << 'sti_key' if self.respond_to?(:sti_key)
+        #   arr
+        # end
+
+        #
+        # returns true / false if any audits have been made
+        #
+        #   Post.audited_versions?   #=> true / false
+        #
+        def audited_versions?
+          audit_model.where(associated_type: name.to_s).count >= 1
+        end
+
+        # grab all audits for a particular model based upon filters
+        #
+        #   Posts.audited_versions(:model_pk => 123)
+        #     #=> filtered by primary_key value
+        #
+        #   Posts.audited_versions(:user_id => 88)
+        #     #=> filtered by user name
+        #
+        #   Posts.audited_versions(:created_at < Date.today - 2)
+        #     #=> filtered to last two (2) days only
+        #
+        #   Posts.audited_versions(:created_at > Date.today - 7)
+        #     #=> filtered to older than last seven (7) days
+        #
+        def audited_versions(opts = {})
+          audit_model.where(opts.merge(associated_type: name.to_s)).order(:version).all
+        end
+
+
+        private
+
+
+        def audit_model
+          const_get(audit_model_name)
+        end
+
+        def audit_model_name
+          ::Sequel::Audited.audited_model_name
+        end
+
+        def set_default_ignored_columns(opts)
+          if opts[:default_ignored_columns]
+            @audited_default_ignored_columns = opts[:default_ignored_columns]
+          else
+            @audited_default_ignored_columns = ::Sequel::Audited.audited_default_ignored_columns
+          end
+        end
+
+        def set_user_method(opts)
+          if opts[:user_method]
+            @audited_current_user_method = opts[:user_method]
+          else
+            @audited_current_user_method = ::Sequel::Audited.audited_current_user_method
+          end
+        end
+
+        def set_reference_method(opts)
+          if opts[:reference_method]
+            @audited_reference_method = opts[:reference_method]
+          end
+        end
+
+      end
+
+
+      #
+      module InstanceMethods
+
+        # Returns who put the post into its current state.
+        #
+        #   post.blame  # => 'joeblogs'
+        #
+        #   post.last_audited_by  # => 'joeblogs'
+        #
+        # Note! returns 'not audited' if there's no audited version (new unsaved record)
+        #
+        def blame
+          v = versions.last unless versions.empty?
+          v ? v.modifier : 'not audited'
+        end
+        alias_method :last_audited_by, :blame
+
+        # Returns who put the post into its current state.
+        #
+        #   post.last_audited_at  # => '2015-12-19 @ 08:24:45'
+        #
+        #   post.last_audited_on  # => 'joeblogs'
+        #
+        # Note! returns 'not audited' if there's no audited version (new unsaved record)
+        #
+        def last_audited_at
+          v = versions.last unless versions.empty?
+          v ? v.created_at : 'not audited'
+        end
+        alias_method :last_audited_on, :last_audited_at
+
+        private
+
+        # extract audited values only
+        def audited_values(event)
+          vals = case event
+          when Sequel::Audited::CREATE
+            self.values
+          when Sequel::Audited::UPDATE
+            (column_changes.empty? ? previous_changes : column_changes)
+          when Sequel::Audited::DESTROY
+            self.values
+          end
+          vals.except(*model.audited_default_ignored_columns)
+        end
+
+        def add_audited(event)
+          changed = audited_values(event)
+          unless changed.blank?
+            add_version(
+              event:      event,
+              changed:    changed
+            )
+          end
+        end
+
+        ### CALLBACKS ###
+
+        def after_create
+          super
+          add_audited(Sequel::Audited::CREATE)
+        end
+
+        def after_update
+          super
+          add_audited(Sequel::Audited::UPDATE)
+        end
+
+        def after_destroy
+          super
+          add_audited(Sequel::Audited::DESTROY)
+        end
+      end
+    end
+  end
+end

data/lib/tasks/sequel-audited/migrate.rake

@@ -0,0 +1,18 @@
+namespace :audited do
+  namespace :migrate do
+    desc 'Installs Sequel::Audited migration, but does not run it'
+    task :install do
+      num = Dir["#{Dir.pwd}/db/migrate/*.rb"].sort.last[0, 3] ||= '001'
+
+      FileUtils.cp(
+        "#{File.dirname(__FILE__)}/templates/audited_migration.rb",
+        "#{Dir.pwd}/db/migrate/#{num}_create_audited_table.rb"
+      )
+    end
+
+    desc 'Updates existing Sequel::Audited migration files with amendments'
+    task :update do
+      puts 'TODO: no updates required yet'
+    end
+  end
+end

data/lib/tasks/sequel-audited/templates/audited_migration.rb

@@ -0,0 +1,23 @@
+Sequel.migration do
+  # created by sequel-audited gem
+
+  up do
+    create_table(:audit_logs) do
+      primary_key :id
+      String    :model_type
+      Integer   :model_pk
+      String    :model_ref
+      String    :event
+      String    :changed,     text: true
+      Integer   :version,     default: 0
+      Integer   :user_id
+      String    :username
+      String    :user_type,   default: 'User'
+      DateTime  :created_at
+    end
+  end
+
+  down do
+    drop_table :audit_logs
+  end
+end