activehistory 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 643c618d011f3af9b72ba7a7fadf3a713aeb0cf4
+  data.tar.gz: bc2d64e5b59d78deb335733d46eef644defc2656
+SHA512:
+  metadata.gz: 53870be2424fa9b20e5bea593fb7691f9cd9e92214d558039ec25122f20ef5eb399cdd406c655e71bc978a5fc62289302d8b8be402f3767c210af78245d332bd
+  data.tar.gz: 4d8b2f3dea6b2aac7922bc8d28868a4b7b6d4f52917d920559f3041ab10fee6e7a5c6fe1aaa661d34b215f5c7f7d8ae6d6690dba93b1bc92ea6b50f0338fed33

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.DS_Store
+/coverage/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in sunstone.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,90 @@
+PATH
+  remote: .
+  specs:
+    activehistory (0.1)
+      activerecord (= 5.0.0.1)
+      arel (~> 7.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (5.0.0.1)
+      activesupport (= 5.0.0.1)
+    activerecord (5.0.0.1)
+      activemodel (= 5.0.0.1)
+      activesupport (= 5.0.0.1)
+      arel (~> 7.0)
+    activesupport (5.0.0.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    addressable (2.4.0)
+    ansi (1.5.0)
+    arel (7.1.2)
+    builder (3.2.2)
+    concurrent-ruby (1.0.2)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    docile (1.1.5)
+    factory_girl (4.7.0)
+      activesupport (>= 3.0.0)
+    faker (1.6.6)
+      i18n (~> 0.5)
+    hashdiff (0.3.0)
+    i18n (0.7.0)
+    json (1.8.3)
+    metaclass (0.0.4)
+    minitest (5.9.1)
+    minitest-reporters (1.1.11)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    mocha (1.1.0)
+      metaclass (~> 0.0.1)
+    pg (0.18.4)
+    rake (11.3.0)
+    rdoc (4.2.2)
+      json (~> 1.4)
+    ruby-progressbar (1.8.1)
+    safe_yaml (1.0.4)
+    sdoc (0.4.1)
+      json (~> 1.7, >= 1.7.7)
+      rdoc (~> 4.0)
+    sdoc-templates-42floors (0.3)
+      sdoc
+    simplecov (0.12.0)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    webmock (2.1.0)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activehistory!
+  bundler
+  factory_girl
+  faker
+  minitest
+  minitest-reporters
+  mocha
+  pg
+  rake
+  rdoc
+  sdoc
+  sdoc-templates-42floors
+  simplecov
+  webmock
+
+BUNDLED WITH
+   1.12.5

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 42Floors
+
+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 @@
+# activehistory-client

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake/testtask'
+require 'rdoc/task'
+
+task :console do
+  exec 'irb -I lib -r activehistory.rb'
+end
+task :c => :console
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+end

data/activehistory.gemspec

@@ -0,0 +1,40 @@
+require File.expand_path("../lib/activehistory/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "activehistory"
+  s.version     = ActiveHistory::VERSION
+  s.authors     = ["Jon Bracy"]
+  s.email       = ["jonbracy@gmail.com"]
+  s.homepage    = "https://activehistory.com"
+  s.summary     = %q{Track changes to ActiveRecord models}
+  s.description = <<~DESC
+    ActiveHistory tracks and logs changes to your ActiveRecord models and
+    relationships for auditing in the future.
+  DESC
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # Developoment 
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rdoc'
+  s.add_development_dependency 'sdoc'
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'minitest-reporters'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'faker'
+  s.add_development_dependency 'factory_girl'
+  s.add_development_dependency 'webmock'
+  s.add_development_dependency 'sdoc-templates-42floors'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'pg'
+
+  # Runtime
+  # s.add_runtime_dependency 'msgpack'
+  # s.add_runtime_dependency 'cookie_store'
+  s.add_runtime_dependency 'arel', '~> 7.0'
+  s.add_runtime_dependency 'activerecord', '5.0.0.1'
+end

data/lib/activehistory.rb

@@ -0,0 +1,39 @@
+module ActiveHistory
+  
+  mattr_accessor :connection
+  
+  def self.configure(settings)
+    @@connection = ActiveHistory::Connection.new(settings)
+  end
+  
+  def self.configured?
+    class_variable_defined?(:@@connection)
+  end
+  
+  def self.url
+    @@connection.url
+  end
+
+  def self.encapsulate(id_or_options=nil)
+    Thread.current[:activehistory_event] = id_or_options
+    yield
+  ensure
+    if Thread.current[:activehistory_event].is_a?(ActiveHistory::Event)
+      Thread.current[:activehistory_event].save!
+    end
+    Thread.current[:activehistory_event] = nil
+  end
+  
+end
+
+require 'activehistory/connection'
+require 'activehistory/event'
+require 'activehistory/action'
+require 'activehistory/regard'
+require 'activehistory/version'
+require 'activehistory/exceptions'
+
+if defined?(ActiveRecord::VERSION)
+  require 'activehistory/adapters/active_record'
+  ActiveRecord::Base.include(ActiveHistory::Adapter::ActiveRecord)
+end

data/lib/activehistory/action.rb

@@ -0,0 +1,20 @@
+class ActiveHistory::Action
+
+  attr_accessor :type, :timestamp, :subject, :diff
+
+  def initialize(attrs)
+    attrs.each do |k,v|
+      self.send("#{k}=", v)
+    end
+  end
+  
+  def as_json
+    {
+      diff: diff.as_json,
+      subject:   @subject,
+      timestamp:    @timestamp.iso8601(3),
+      type:         @type
+    }
+  end
+
+end

data/lib/activehistory/adapters/active_record.rb

@@ -0,0 +1,202 @@
+module ActiveHistory::Adapter
+  module ActiveRecord
+    extend ActiveSupport::Concern
+  
+    class_methods do
+    
+      def self.extended(other)
+        other.before_save     :activehistory_start
+        other.before_destroy  :activehistory_start
+        
+        other.after_create  { activehistory_track(:create) }
+        other.after_update  { activehistory_track(:update) }
+        other.before_destroy { activehistory_track(:destroy) }
+        
+        other.after_commit  { activehistory_complete }
+      end
+      
+      def inherited(subclass)
+        super
+        
+        subclass.instance_variable_set('@activehistory', @activehistory.clone) if defined?(@activehistory)
+      end
+      
+      def track(exclude: [], habtm_model: nil)
+        @activehistory = {exclude: Array(exclude), habtm_model: habtm_model}
+      end
+      
+      def has_and_belongs_to_many(name, scope = nil, options = {}, &extension)
+        super
+        habtm_model = self.const_get("HABTM_#{name.to_s.camelize}")
+        
+        habtm_model.track habtm_model: {
+          :left_side => { foreign_key: "#{base_class.name.underscore}_id", inverse_of: name.to_s },
+          name.to_s.singularize.to_sym => {inverse_of: self.name.underscore.pluralize.to_s}
+        }
+        
+        callback = ->(method, owner, record) {
+          owner.activehistory_association_udpated(
+            record.class.reflect_on_association(owner.class.reflect_on_association(name.to_s).options[:inverse_of].to_s),
+            owner.id,
+            removed: [record.id],
+            timestamp: owner.activehistory_timestamp
+          )
+          record.activehistory_association_udpated(
+            owner.class.reflect_on_association(name.to_s),
+            record.id,
+            removed: [owner.id],
+            timestamp: owner.activehistory_timestamp
+          )
+        }
+        self.send("after_remove_for_#{name}=", Array(self.send("after_remove_for_#{name}")).compact + [callback])
+      end
+    end
+    
+    def activehistory_id
+      "#{self.class.name}/#{id}"
+    end
+    
+    def activehistory_timestamp
+      @activehistory_timestamp ||= Time.now.utc
+    end
+    
+    def activehistory_start
+      if activehistory_tracking && !instance_variable_defined?(:@activehistory_finish)
+        @activehistory_finish = !Thread.current[:activehistory_event]
+      end
+      @activehistory_timestamp = Time.now.utc
+    end
+    
+    def activehistory_complete
+      @activehistory_timestamp = nil
+      if instance_variable_defined?(:@activehistory_finish) && @activehistory_finish && activehistory_tracking
+        activehistory_event.save! if activehistory_event
+        Thread.current[:activehistory_event] = nil
+        @activehistory_timestamp = nil
+      end
+    end
+    
+    def activehistory_tracking
+      if ActiveHistory.configured? && self.class.instance_variable_defined?(:@activehistory)
+        self.class.instance_variable_get(:@activehistory)
+      end
+    end
+    
+    def activehistory_event
+      case Thread.current[:activehistory_event]
+      when ActiveHistory::Event
+        Thread.current[:activehistory_event]
+      when Hash
+        Thread.current[:activehistory_event][:timestamp] ||= @activehistory_timestamp
+        Thread.current[:activehistory_event] = ActiveHistory::Event.new(Thread.current[:activehistory_event])
+      when Fixnum
+      else
+        Thread.current[:activehistory_event] = ActiveHistory::Event.new(timestamp: @activehistory_timestamp)
+      end
+    end
+    
+    def activehistory_track(type)
+      return if !activehistory_tracking
+      
+      if type == :create || type == :update
+        diff = self.changes.select { |k,v| !activehistory_tracking[:exclude].include?(k.to_sym) }
+        if type == :create
+          self.class.columns.each do |column|
+            if !diff[column.name] && !activehistory_tracking[:exclude].include?(column.name.to_sym) && column.default != self.attributes[column.name]
+              diff[column.name] = [nil, self.attributes[column.name]]
+            end
+          end
+        end
+      elsif type == :destroy
+        diff = self.attributes.select { |k| !activehistory_tracking[:exclude].include?(k.to_sym) }.map { |k, i| [k, [i, nil]] }.to_h
+      end
+      
+      return if type == :update && diff.size == 0
+      
+      if !activehistory_tracking[:habtm_model]
+        activehistory_event.action!({
+          type: type,
+          subject: self.activehistory_id,
+          diff: diff,
+          timestamp: @activehistory_timestamp
+        })
+      end
+      
+      self._reflections.each do |key, reflection|
+        foreign_key = activehistory_tracking.dig(:habtm_model, reflection.name, :foreign_key) || reflection.foreign_key
+
+        if areflection = self.class.reflect_on_association(reflection.name)
+          if areflection.macro == :has_and_belongs_to_many && type == :create
+            self.send("#{areflection.name.to_s.singularize}_ids").each do |fid|
+              next unless fid
+              activehistory_association_udpated(areflection, fid, added: [diff['id'][1]], timestamp: activehistory_timestamp)
+              activehistory_association_udpated(areflection.klass.reflect_on_association(areflection.options[:inverse_of]), diff['id'][1], added: [fid], timestamp: activehistory_timestamp, type: :create)
+            end
+          elsif areflection.macro == :has_and_belongs_to_many && type == :destroy
+            self.send("#{areflection.name.to_s.singularize}_ids").each do |fid|
+              activehistory_association_udpated(areflection, fid, removed: [diff['id'][0]], timestamp: activehistory_timestamp, type: :update)
+              activehistory_association_udpated(areflection.klass.reflect_on_association(areflection.options[:inverse_of]), diff['id'][0], removed: [fid], timestamp: activehistory_timestamp, type: :update)
+            end
+          end
+        end
+        
+        next unless reflection.macro == :belongs_to && (type == :destroy || diff.has_key?(foreign_key))
+        
+        case type
+        when :create
+          old_id = nil
+          new_id = diff[foreign_key][1]
+        when :destroy
+          old_id = diff[foreign_key][0]
+          new_id = nil
+        else
+          old_id = diff[foreign_key][0]
+          new_id = diff[foreign_key][1]
+        end
+        
+        relation_id = self.id || diff.find { |k, v| k != foreign_key }[1][1]
+        
+        if reflection.polymorphic?
+        else
+          activehistory_association_udpated(reflection, old_id, removed: [relation_id], timestamp: activehistory_timestamp) if old_id
+          activehistory_association_udpated(reflection, new_id, added:   [relation_id], timestamp: activehistory_timestamp) if new_id
+        end
+        
+      end
+      
+    end
+
+    def activehistory_association_udpated(reflection, id, added: [], removed: [], timestamp: nil, type: :update)
+      if inverse_of = activehistory_tracking.dig(:habtm_model, reflection.name, :inverse_of)
+        inverse_of = reflection.klass.reflect_on_association(inverse_of)
+      else
+        inverse_of = reflection.inverse_of
+      end
+
+      if inverse_of.nil?
+        puts "NO INVERSE for #{self.class}.#{reflection.name}!!!"
+        return
+      end
+      
+      model_name = reflection.klass.base_class.model_name.name
+      
+      action = activehistory_event.action_for("#{model_name}/#{id}") || activehistory_event.action!({
+        type: type,
+        subject: "#{model_name}/#{id}",
+        timestamp: timestamp# || Time.now
+      })
+      
+      action.diff ||= {}
+      if inverse_of.collection? || activehistory_tracking[:habtm_model]
+        diff_key = "#{inverse_of.name.to_s.singularize}_ids"
+        action.diff[diff_key] ||= [[], []]
+        action.diff[diff_key][0] |= removed
+        action.diff[diff_key][1] |= added
+      else
+        diff_key = "#{inverse_of.name.to_s.singularize}_id"
+        action.diff[diff_key] ||= [removed.first, added.first]
+      end
+    end
+
+  end
+end