track_history 0.0.4 → 0.0.7

data/lib/track_history.rb

@@ -19,71 +19,114 @@ module TrackHistory
     # Takes a hash of options, which can only be :model_name to force a different model name
     # Default model name is ModelHistory
     def track_history(options = {}, &block)
-      options.assert_valid_keys(:model_name, :table_name)
-      @historical_fields = []
-      @historical_tracks = {}
-      define_historical_model(self, options[:model_name], options[:table_name])
-      module_eval(&block) if block_given?
+      options.assert_valid_keys(:model_name, :table_name, :reference)
+      define_historical_model(self, options[:model_name], options[:table_name], options.has_key?(:reference) ? !!options[:reference] : true, &block)
     end
 
-    def annotate(field, &block) # haha
-      @historical_tracks ||= {}
-      @historical_tracks[field] = block
-      unless @klass_reference.columns_hash.has_key?(field.is_a?(Symbol) ? field.to_s : field) 
-        raise ActiveRecord::StatementInvalid.new("No such attribute '#{field}' on #{@klass_reference.name}")
-      end
+    def historical_class
+      @klass_reference
     end
 
     def historical_fields
-      @historical_fields
-    end
-
-    def historical_tracks
-      @historical_tracks
+      @klass_reference.historical_fields.keys
     end
 
     private
 
-    def define_historical_model(base, model_name, table_name)
+    def define_historical_model(base, model_name, table_name, track_reference, &block)
+
+      # figure out the model name
       model_name ||= "#{base.name}History"
-      klass = Object.const_set(model_name, Class.new(ActiveRecord::Base))
-      @klass_reference = klass
-     
+      @klass_reference = Object.const_set(model_name, Class.new(ActiveRecord::Base))
+
+      # set up a way to record tracks
+      @klass_reference.instance_variable_set(:@track_historical_reference, track_reference) 
+      @klass_reference.send(:extend, HistoryMethods)
+
       # infer fields
-      klass.send(:table_name=, table_name) unless table_name.nil?
-      klass.columns_hash.each_key do |k| 
+      @klass_reference.send(:table_name=, table_name) unless table_name.nil?
+      @klass_reference.columns_hash.each_key do |k| 
         matches = k.match(/(.+?)_before$/)
         if matches && matches.size == 2 && field_name = matches[1]
-          @historical_fields << field_name if klass.columns_hash.has_key?("#{field_name}_after")
+          next if @klass_reference.historical_fields.has_key?(field_name) # override inferrences
+          @klass_reference.historical_fields[field_name] = { :before => "#{field_name}_before".to_sym, :after => "#{field_name}_after".to_sym }
         end
       end
      
+      # allow other things to be specified
+      @klass_reference.module_eval(&block) if block_given?
+      
       # create the history class
       rel = base.name.singularize.underscore.downcase.to_sym
-      klass.belongs_to rel
-      klass.send(:alias_method, :historical_relation, rel)
-      klass.send(:include, HistoricalHelpers)
+      @klass_reference.send(:include, HistoricalRelationHelpers)
+
+      # create a backward reference
+      if track_reference
+        @klass_reference.belongs_to rel
+        @klass_reference.send(:alias_method, :historical_relation, rel)
+        has_many :histories, :class_name => model_name, :order => 'created_at desc' if track_reference
+      end
 
       # tell the other class about us
       # purposely don't define these until after getting historical_fields
-      has_many :histories, :class_name => model_name, :order => 'created_at desc'
       before_update :record_historical_changes
 
     end
 
   end
 
-  module HistoricalHelpers
+  module HistoryMethods
+
+    attr_reader :historical_fields
+
+    def track_historical_reference?
+      @track_historical_reference
+    end
+
+    def historical_fields
+      @historical_fields ||= {}
+    end
+
+    def historical_tracks
+      @historical_tracks ||= {}
+    end
+
+    def field(field, options = {}) # TODO rename
+      field_s = field.is_a?(String) ? field : field.to_s
+      historical_fields[field_s] = { 
+        :before => options[:before] || "#{field}_before".to_sym,
+        :after => options[:after] || "#{field}_after".to_sym
+      }
+      nil
+    end
+
+    def annotate(field, options = {}, &block) # haha
+      options.assert_valid_keys(:as)
+      save_as = options.has_key?(:as) ? options[:as] : field
+
+      unless columns_hash.has_key?(save_as.to_s)
+        raise ActiveRecord::StatementInvalid.new("No such attribute '#{field}' on #{@klass_reference.name}")
+      end
+
+      historical_tracks[save_as] = block.nil? ? field : block
+    end
+
+  end
+
+  module HistoricalRelationHelpers
 
     # Get a list of the modifications in a given history
     def modifications
-      historical_relation.class.historical_fields.reject do |field|
-        send(:"#{field}_before") == send(:"#{field}_after")
-      end
+      self.class.historical_fields.reject do |field, options|
+        send(options[:before]) == send(options[:after])
+      end.keys
     end
 
     def to_s
-      'modified ' + modifications.join(', ') + " on #{historical_relation}"
+      return 'modified nothing' if modifications.empty?
+      str = 'modified ' + modifications.sort.join(', ')
+      str += " on #{historical_relation}" if self.class.instance_variable_get(:@track_historical_reference)
+      str
     end
 
   end
@@ -93,19 +136,26 @@ module TrackHistory
     private
 
     def record_historical_changes
-      return if self.class.historical_fields.empty?
+      historical_fields = self.class.historical_class.historical_fields
+      historical_tracks = self.class.historical_class.historical_tracks
+      return if historical_fields.empty? && historical_tracks.empty?
       # go through each and build the hashes
       attributes = {}
-      self.class.historical_fields.each do |field|
+      historical_fields.each do |field, field_options|
         next unless send(:"#{field}_changed?")
-        attributes.merge! :"#{field}_before" => send(:"#{field}_was"), :"#{field}_after" => send(field.to_sym)
+        attributes.merge! field_options[:before] => send(:"#{field}_was"), field_options[:after] => send(field.to_sym)
       end
       return if attributes.empty? # nothing changed - skip out 
       # then go through each track
-      self.class.historical_tracks.each do |field, block|
-        attributes[field] = block.nil? ? send(field) : (block.arity == 1 ? block.call(self) : instance_eval(&block)) # give access to the user object
+      historical_tracks.each do |field, block|
+        attributes[field] = block.is_a?(Symbol) ? send(block) : (block.arity == 1 ? block.call(self) : instance_eval(&block)) # give access to the user object
+      end
+      # record the change
+      if self.class.historical_class.track_historical_reference?
+        self.histories.create(attributes)
+      else
+        self.class.historical_class.create(attributes)
       end
-      self.histories.create(attributes)
     end
 
   end

data/lib/track_history/version.rb

@@ -1,5 +1,5 @@
 module TrackHistory
 
-  VERSION = '0.0.4'
+  VERSION = '0.0.7'
 
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: track_history
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 7
+  version: 0.0.7
 platform: ruby
 authors: 
 - John Crepezzi
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-10 00:00:00 -05:00
+date: 2011-01-11 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,6 +32,20 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mysql
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
 description: Smart, performant model auditing
 email: john.crepezzi@patch.com
 executables: []