culturecode-track_changes 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d9f210dc9b044e9606eaceda2cb73ee6b16d41ba
+  data.tar.gz: 381b4764ef7f663a87482ce71d91510769a422b2
+SHA512:
+  metadata.gz: ebe1afa939c705490216f2b144a359cf44d18c59d694745d6d314ca3e848e70e97f8831a5c743f4be10ac2e824c1ac2c69c4288389eef68a1e6eb6340997c9cb
+  data.tar.gz: 235713afc3708a6b5208350fb201e53cde080630779003f14a4034704cf248cbca2e0e390a9bf4b2be3584924c14b98842b42525d3472f987d2d93fc3a0b749f

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Nicholas Jakobsen
+
+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,44 @@
+# Track Changes
+
+## Installation
+
+Migration
+```ruby
+class CreateTrackChangesTables < ActiveRecord::Migration
+  def change
+    create_table :track_changes_snapshots do |t|
+      t.references :record, :polymorphic => true
+      t.text :state
+      t.timestamps
+    end
+
+    create_table :track_changes_diffs do |t|
+      t.references :record, :polymorphic => true
+      t.text :from
+      t.text :to
+      t.string :action
+      t.string :changes_by
+      t.timestamps
+    end
+  end
+end
+```
+
+## Usage
+
+In your model
+
+```ruby
+class Person < ActiveRecord::Base
+  tracks_changes # may also pass an options hash
+end
+```
+
+### Options
+By default all model attributes are tracked, except the primary_key, usually ```id```, ```created_at```, and ```updated_at```.
+
+- ```:only``` accepts a field name or array of field names to track instead of the default fields
+- ```:except``` accepts a field name or array of field names to ignore
+- ```:methods``` accepts a field name or array of field names to track in addition to the default fields
+- ```:track_timestamps``` accepts a boolean, enabling or disabling tracking of ```created_at``` and ```updated_at```
+- ```:track_primary_key``` accepts a boolean, enabling or disabling tracking of the model's primary key

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'TrackChanges'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/helpers/track_changes/diff_helper.rb

@@ -0,0 +1,49 @@
+module TrackChanges
+  module DiffHelper
+    def diff_action(diff)
+      case diff.action
+      when 'create'
+        'added'
+      when 'update'
+        'updated'
+      when 'destroy'
+        'deleted'
+      end
+    end
+
+    def diff_change_sentence(diff, field, changes, link_models = [])
+      from, to = changes.is_a?(Array) ? changes : [nil, changes]
+      # return if diff.action == 'destroy'
+      return if from.blank? && to.blank?
+
+      if record = diff.record
+        field_name = diff.record.class.human_attribute_name(field)
+        reflection = diff.record.class.reflections.values.detect {|reflection| reflection.foreign_key == field.to_s }
+      end
+
+      if reflection
+        from = reflection.klass.find(from) if from.present?
+        to   = reflection.klass.find(to)   if to.present?
+      end
+
+      if from.blank?
+        content_tag(:span, field_name, :class => 'field_name') + " set to " + content_tag(:span, link_diff_field_value(to, link_models), :class => 'field_value')
+      elsif to.blank?
+        content_tag(:span, field_name, :class => 'field_name') + " removed"
+      else
+        content_tag(:span, field_name, :class => 'field_name') + " changed from " + content_tag(:span, link_diff_field_value(from, link_models), :class => 'field_value') + " to " + content_tag(:span, link_diff_field_value(to, link_models), :class => 'field_value')
+      end
+    end
+
+    def link_diff_field_value(value, link_models = [])
+      case value
+      when Array
+        value.collect{|v| link_diff_field_value(v, link_models) }.to_sentence.html_safe
+      when *link_models
+        link_to(value.to_s, value)
+      else
+        value
+      end
+    end
+  end
+end

data/app/models/track_changes/diff.rb

@@ -0,0 +1,18 @@
+module TrackChanges
+  class Diff < ActiveRecord::Base
+    self.table_name = "track_changes_diffs"
+
+    belongs_to :record, :polymorphic => true
+
+    serialize :from, Hash
+    serialize :to, Hash
+
+    # Returns a hash of changes where the key is the field name
+    # and the value is an array of the from value and the to value
+    def changes
+      Hash[(from.keys + to.keys).collect do |key|
+        [key, [from[key], to[key]]]
+      end]
+    end
+  end
+end

data/app/models/track_changes/snapshot.rb

@@ -0,0 +1,42 @@
+module TrackChanges
+  class Snapshot < ActiveRecord::Base
+    self.table_name = "track_changes_snapshots"
+
+    belongs_to :record, :polymorphic => true
+
+    serialize :state, Hash
+
+    before_save :capture_record_state
+
+    # Creates a diff object that shows the changes between this snapshot and the record's state
+    def create_diff(diff_attributes = {})
+      record_state   = self.class.record_state(record)
+      snapshot_state = self.state
+      from           = {}
+      to             = {}
+
+      record.class.track_changes_fields.each do |key|
+        if snapshot_state.key?(key) && snapshot_state[key] != record_state[key]
+          from[key] = snapshot_state[key]
+          to[key] = record_state[key]
+        end
+      end
+      diff_attributes = diff_attributes.reverse_merge(:from => from, :to => to)
+      record.diffs.create!(diff_attributes) unless diff_attributes[:from].empty? && diff_attributes[:to].empty?
+    end
+
+    # Updates the snapshot to the current record state
+    def update
+      save
+    end
+
+    def capture_record_state
+      self.state = self.class.record_state(record)
+    end
+
+    # Returns a hash of the current values for all tracked fields on the record
+    def self.record_state(record)
+      Hash[record.class.track_changes_fields.collect {|method_name| [method_name, record.send(method_name)] }]
+    end
+  end
+end

data/config/initializers/extend_activerecord.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.send :extend, TrackChanges::ActsMethod

data/config/routes.rb

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

data/lib/tasks/track_changes_tasks.rake

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

data/lib/track_changes/engine.rb

@@ -0,0 +1,6 @@
+require 'track_changes/track_changes'
+
+module TrackChanges
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/track_changes/track_changes.rb

@@ -0,0 +1,54 @@
+module TrackChanges
+  module ActsMethod
+    def tracks_changes(options = {})
+      extend ClassMethods
+      include InstanceMethods
+
+      class_attribute :track_changes_options
+      self.track_changes_options = options
+
+      attr_accessor :track_changes # Faux attribute to allow disabling of change tracking on this record
+      attr_accessor :track_changes_by # Faux attribute to store who made the changes so we can save it in the diff
+
+      has_one :snapshot, :as => :record, :class_name => 'TrackChanges::Snapshot' # A representation of this record as it was last saved
+      has_many :diffs, :as => :record, :class_name => 'TrackChanges::Diff' # A representation of changes made between saves through this record's lifetime
+
+      after_save :persist_tracked_changes
+    end
+  end
+
+  module ClassMethods
+    # Returns the method names to call to fetch the fields tracked for changes
+    def track_changes_fields
+      fields =  Array(track_changes_options[:only]).collect(&:to_s).presence || self.attribute_names
+      fields -= Array(track_changes_options[:except]).collect(&:to_s)
+      fields += Array(track_changes_options[:methods]).collect(&:to_s)
+      fields -= ['created_at', 'updated_at'] unless track_changes_options[:track_timestamps]
+      fields -= [primary_key] unless track_changes_options[:track_primary_key]
+    end
+  end
+
+  module InstanceMethods
+    private
+
+    # Compares the last tracked changes to the current state and saves a diff of the changes
+    def persist_tracked_changes
+      return if track_changes == false
+
+      new_record = id_was.blank?
+      action     = new_record ? 'create' : 'update'
+      changes_by = track_changes_by.is_a?(ActiveRecord::Base) ? track_changes_by.id : track_changes_by
+
+      if snapshot
+        snapshot.create_diff(:action => action, :changes_by => changes_by)
+        snapshot.update
+      elsif new_record
+        create_snapshot
+        snapshot.create_diff(:action => action, :changes_by => changes_by, :from => {}, :to => snapshot.state)
+      else # We started tracking changes after the item was created
+        create_snapshot
+        snapshot.create_diff(:action => action, :changes_by => changes_by, :from => {})
+      end
+    end
+  end
+end

data/lib/track_changes/version.rb

@@ -0,0 +1,3 @@
+module TrackChanges
+  VERSION = "0.0.1"
+end

data/lib/track_changes.rb

@@ -0,0 +1,4 @@
+require "track_changes/engine"
+
+module TrackChanges
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: culturecode-track_changes
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nicholas Jakobsen, Ryan Wallace
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Easily track changes to various ActiveRecord models. Supports both attribute
+  and method tracking.
+email:
+- contact@culturecode.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/helpers/track_changes/diff_helper.rb
+- app/models/track_changes/diff.rb
+- app/models/track_changes/snapshot.rb
+- config/initializers/extend_activerecord.rb
+- config/routes.rb
+- lib/tasks/track_changes_tasks.rake
+- lib/track_changes.rb
+- lib/track_changes/engine.rb
+- lib/track_changes/track_changes.rb
+- lib/track_changes/version.rb
+homepage: https://github.com/culturecode/track_changes
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.7
+signing_key: 
+specification_version: 4
+summary: Easily track changes to various ActiveRecord models
+test_files: []