culturecode-track_changes 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9f210dc9b044e9606eaceda2cb73ee6b16d41ba
-  data.tar.gz: 381b4764ef7f663a87482ce71d91510769a422b2
+  metadata.gz: 07ad7f3aeec94be71f57d6d3e0b3726ab473b8f4
+  data.tar.gz: 3171e12d387c900f3ee7e1892d45c51bc96ab11e
 SHA512:
-  metadata.gz: ebe1afa939c705490216f2b144a359cf44d18c59d694745d6d314ca3e848e70e97f8831a5c743f4be10ac2e824c1ac2c69c4288389eef68a1e6eb6340997c9cb
-  data.tar.gz: 235713afc3708a6b5208350fb201e53cde080630779003f14a4034704cf248cbca2e0e390a9bf4b2be3584924c14b98842b42525d3472f987d2d93fc3a0b749f
+  metadata.gz: c2ef18640299c7abaf104f0c79552de9cd0c7334199500dc0015450a8bd626a1c1741f51871ea22f69ad9a372a9d1631ebdaf794012948715a99ca61ef1e977c
+  data.tar.gz: 58fa61d8192b607a59c5ab10392667d2be9c10193b836a75ad9395869236313919d3b3d997f0a068760f3308dea32be6bdbe6dd810b6467776b69e2b7669903a

data/README.md

@@ -26,8 +26,6 @@ end
 
 ## Usage
 
-In your model
-
 ```ruby
 class Person < ActiveRecord::Base
   tracks_changes # may also pass an options hash
@@ -42,3 +40,23 @@ By default all model attributes are tracked, except the primary_key, usually ```
 - ```: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
+
+### Attribution
+Changes can be attributed to a particular source. The source is saved as a string
+in the ```:changes_by column``` of the record. If given an instance of ActiveRecord::Base,
+the record's id will be used.
+
+```ruby
+# Inline attribution
+person.save(:changes_by => 'Joe Changems')
+
+# Block-level attribution
+attribute_changes_to 'Joe Changems' do
+  person.save
+end
+
+# Controller-level attribution
+class MyController < ApplicationController
+  attribute_changes_to :current_user
+end
+```

data/app/helpers/track_changes/diff_helper.rb

@@ -11,9 +11,20 @@ module TrackChanges
       end
     end
 
+    #
+    # Generate a human readable sentence for a change in a TrackChanges::Diff
+    #
+    # diff        - a TrackChanges::Diff object
+    # field       - the specific field of the diff (e.g. collection_id)
+    # changes     - an array of the previous and current value for the field
+    # link_models - an array of classes of models that should generate as in-sentence links
+    #
     def diff_change_sentence(diff, field, changes, link_models = [])
       from, to = changes.is_a?(Array) ? changes : [nil, changes]
-      # return if diff.action == 'destroy'
+
+      from.reject!(&:blank?) if from.is_a?(Array)
+      to.reject!(&:blank?) if to.is_a?(Array)
+
       return if from.blank? && to.blank?
 
       if record = diff.record
@@ -22,8 +33,8 @@ module TrackChanges
       end
 
       if reflection
-        from = reflection.klass.find(from) if from.present?
-        to   = reflection.klass.find(to)   if to.present?
+        from = reflection.klass.find_by_id(from) || content_tag(:span, 'DELETED', :class => 'deleted', :title => "This #{field_name} has been deleted") if from.present?
+        to   = reflection.klass.find_by_id(to)   || content_tag(:span, 'DELETED', :class => 'deleted', :title => "This #{field_name} has been deleted") if to.present?
       end
 
       if from.blank?

data/app/models/track_changes/snapshot.rb

@@ -8,6 +8,11 @@ module TrackChanges
 
     before_save :capture_record_state
 
+    # 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
+
     # 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)
@@ -33,10 +38,5 @@ module TrackChanges
     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

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

data/config/initializers/extend_application_controller.rb

@@ -0,0 +1 @@
+ApplicationController.send :extend, TrackChanges::Controller::Base

data/lib/track_changes/attribution.rb

@@ -0,0 +1,13 @@
+module TrackChanges
+  mattr_accessor :default_attribution
+
+  # Set the source used for implict changes_by attribution
+  # for the duration of the block
+  def self.with_changes_attributed_to(new_source, &block)
+    old_source = self.default_attribution
+    self.default_attribution = new_source
+    block.call
+  ensure
+    self.default_attribution = old_source
+  end
+end

data/lib/track_changes/controller.rb

@@ -0,0 +1,11 @@
+module TrackChanges
+  module Controller
+    module Base
+      def attribute_changes_to(method_name)
+        around_action do |controller, action_block|
+          TrackChanges.with_changes_attributed_to controller.send(method_name), &action_block
+        end
+      end
+    end
+  end
+end

data/lib/track_changes/engine.rb

@@ -1,4 +1,6 @@
-require 'track_changes/track_changes'
+require 'track_changes/model'
+require 'track_changes/controller'
+require 'track_changes/attribution'
 
 module TrackChanges
   class Engine < ::Rails::Engine

data/lib/track_changes/model.rb

@@ -0,0 +1,69 @@
+module TrackChanges
+  module Model
+    module Base
+      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_writer   :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
+
+      # Create snapshots for all records so that the next changes made are captured
+      # This can be used to init track changes on existing records
+      def snapshot_all
+        # Update existing snapshots
+        joins(:snapshot).find_each {|record| record.snapshot.update }
+        # Create new snapshots
+        where.not(:id => joins(:snapshot)).find_each(&:create_snapshot)
+      end
+    end
+
+    module InstanceMethods
+      private
+
+      def track_changes_by
+        @track_changes_by || TrackChanges.default_attribution
+      end
+
+      # 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
+end

data/lib/track_changes/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: culturecode-track_changes
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Nicholas Jakobsen, Ryan Wallace
@@ -53,11 +53,14 @@ files:
 - app/models/track_changes/diff.rb
 - app/models/track_changes/snapshot.rb
 - config/initializers/extend_activerecord.rb
+- config/initializers/extend_application_controller.rb
 - config/routes.rb
 - lib/tasks/track_changes_tasks.rake
 - lib/track_changes.rb
+- lib/track_changes/attribution.rb
+- lib/track_changes/controller.rb
 - lib/track_changes/engine.rb
-- lib/track_changes/track_changes.rb
+- lib/track_changes/model.rb
 - lib/track_changes/version.rb
 homepage: https://github.com/culturecode/track_changes
 licenses:

data/lib/track_changes/track_changes.rb

@@ -1,54 +0,0 @@
-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