activerecord-userstamp 2.1.1

data/lib/active_record/userstamp/stampable.rb

@@ -0,0 +1,174 @@
+module ActiveRecord::Userstamp
+  # Determines what default columns to use for recording the current stamper.
+  # By default this is set to false, so the plug-in will use columns named
+  # <tt>creator_id</tt>, <tt>updater_id</tt>, and <tt>deleter_id</tt>.
+  #
+  # To turn compatibility mode on, place the following line in your environment.rb
+  # file:
+  #
+  #   Ddb::Userstamp.compatibility_mode = true
+  #
+  # This will cause the plug-in to use columns named <tt>created_by</tt>,
+  # <tt>updated_by</tt>, and <tt>deleted_by</tt>.
+  mattr_accessor :compatibility_mode
+  @@compatibility_mode = false
+
+  # Extends the stamping functionality of ActiveRecord by automatically recording the model
+  # responsible for creating, updating, and deleting the current object. See the Stamper
+  # and Userstamp modules for further documentation on how the entire process works.
+  module Stampable
+    def self.included(base) #:nodoc:
+      super
+
+      base.extend(ClassMethods)
+      base.class_eval do
+        include InstanceMethods
+
+        # Should ActiveRecord record userstamps? Defaults to true.
+        class_attribute  :record_userstamp
+        self.record_userstamp = true
+
+        # Which class is responsible for stamping? Defaults to :user.
+        class_attribute  :stamper_class_name
+
+        # What column should be used for the creator stamp?
+        # Defaults to :creator_id when compatibility mode is off
+        # Defaults to :created_by when compatibility mode is on
+        class_attribute  :creator_attribute
+
+        # What column should be used for the updater stamp?
+        # Defaults to :updater_id when compatibility mode is off
+        # Defaults to :updated_by when compatibility mode is on
+        class_attribute  :updater_attribute
+
+        # What column should be used for the deleter stamp?
+        # Defaults to :deleter_id when compatibility mode is off
+        # Defaults to :deleted_by when compatibility mode is on
+        class_attribute  :deleter_attribute
+      end
+    end
+
+    module ClassMethods
+      # This method is automatically called on for all classes that inherit from
+      # ActiveRecord, but if you need to customize how the plug-in functions, this is the
+      # method to use. Here's an example:
+      #
+      #   class Post < ActiveRecord::Base
+      #     stampable :stamper_class_name => :person,
+      #               :creator_attribute  => :create_user,
+      #               :updater_attribute  => :update_user,
+      #               :deleter_attribute  => :delete_user,
+      #               :deleter            => true,
+      #               :with_deleted       => true
+      #   end
+      #
+      # The method will automatically setup all the associations,
+      # and create <tt>before_validation</tt> & <tt>before_destroy</tt> callbacks for doing the stamping.
+      #
+      # By default, the deleter association and before filter are not defined unless
+      # you set the :deleter_attribute or set the :deleter option to true.
+      #
+      # When using the new acts_as_paranoid gem (https://github.com/goncalossilva/rails3_acts_as_paranoid)
+      # the :with_deleted option can be used to setup the associations to return objects that have been soft deleted.
+      #
+      def stampable(options = {})
+        compatability = ActiveRecord::Userstamp.compatibility_mode
+        defaults  = {
+          :stamper_class_name => :user,
+          :creator_attribute  => (compatability ? :created_by : :creator_id),
+          :updater_attribute  => (compatability ? :updated_by : :updater_id),
+          :deleter_attribute  => (compatability ? :deleted_by : :deleter_id),
+          :deleter            => options.has_key?(:deleter_attribute),
+          :with_deleted       => false
+        }.merge(options)
+
+        self.stamper_class_name = defaults[:stamper_class_name].to_sym
+        self.creator_attribute  = defaults[:creator_attribute].to_sym
+        self.updater_attribute  = defaults[:updater_attribute].to_sym
+        self.deleter_attribute  = defaults[:deleter_attribute].to_sym
+
+        class_eval do
+          klass = "::#{stamper_class_name.to_s.singularize.camelize}"
+
+          if defaults[:with_deleted]
+            belongs_to :creator, :class_name => klass, :foreign_key => creator_attribute, :with_deleted => true
+            belongs_to :updater, :class_name => klass, :foreign_key => updater_attribute, :with_deleted => true
+          else
+            belongs_to :creator, :class_name => klass, :foreign_key => creator_attribute
+            belongs_to :updater, :class_name => klass, :foreign_key => updater_attribute
+          end
+
+          before_validation :set_updater_attribute
+          before_validation :set_creator_attribute, :on => :create
+          before_save :set_updater_attribute
+          before_save :set_creator_attribute, :on => :create
+
+          if defaults[:deleter]
+            if defaults[:with_deleted]
+              belongs_to :deleter, :class_name => klass, :foreign_key => deleter_attribute, :with_deleted => true
+            else
+              belongs_to :deleter, :class_name => klass, :foreign_key => deleter_attribute
+            end
+
+            before_destroy :set_deleter_attribute
+
+          end
+        end
+      end
+
+      # Temporarily allows you to turn stamping off. For example:
+      #
+      #   Post.without_stamps do
+      #     post = Post.find(params[:id])
+      #     post.update_attributes(params[:post])
+      #     post.save
+      #   end
+      def without_stamps
+        original_value = self.record_userstamp
+        self.record_userstamp = false
+        yield
+      ensure
+        self.record_userstamp = original_value
+      end
+
+      def stamper_class #:nodoc:
+        stamper_class_name.to_s.camelize.constantize rescue nil
+      end
+    end
+
+    module InstanceMethods #:nodoc:
+      private
+        def has_stamper?
+          !self.class.stamper_class.nil? && !self.class.stamper_class.stamper.nil? rescue false
+        end
+
+        def set_creator_attribute
+          return unless self.record_userstamp
+          if respond_to?(self.creator_attribute.to_sym) && has_stamper?
+            if self.send(self.creator_attribute.to_sym).blank?
+              self.send("#{self.creator_attribute}=".to_sym, self.class.stamper_class.stamper)
+            end
+          end
+        end
+
+        def set_updater_attribute
+          return unless self.record_userstamp
+          # only set updater if the record is new or has changed
+          # or contains a serialized attribute (in which case the attribute value is always updated)
+          return unless self.new_record? || self.changed? || self.class.serialized_attributes.present?
+          if respond_to?(self.updater_attribute.to_sym) && has_stamper?
+            self.send("#{self.updater_attribute}=".to_sym, self.class.stamper_class.stamper)
+          end
+        end
+
+        def set_deleter_attribute
+          return unless self.record_userstamp
+          if respond_to?(self.deleter_attribute.to_sym) && has_stamper?
+            self.send("#{self.deleter_attribute}=".to_sym, self.class.stamper_class.stamper)
+            save
+          end
+        end
+      #end private
+    end
+  end
+end

data/lib/active_record/userstamp/stamper.rb

@@ -0,0 +1,39 @@
+module ActiveRecord::Userstamp
+  module Stamper
+    def self.included(base) # :nodoc:
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def model_stamper
+        # don't allow multiple calls
+        return if self.included_modules.include?(ActiveRecord::Userstamp::Stamper::InstanceMethods)
+        send(:extend, ActiveRecord::Userstamp::Stamper::InstanceMethods)
+      end
+    end
+
+    module InstanceMethods
+      # Used to set the stamper for a particular request. See the Userstamp module for more
+      # details on how to use this method.
+      def stamper=(object)
+        object_stamper = if object.is_a?(ActiveRecord::Base)
+          object.send("#{object.class.primary_key}".to_sym)
+        else
+          object
+        end
+
+        Thread.current["#{self.to_s.downcase}_#{self.object_id}_stamper"] = object_stamper
+      end
+
+      # Retrieves the existing stamper for the current request.
+      def stamper
+        Thread.current["#{self.to_s.downcase}_#{self.object_id}_stamper"]
+      end
+
+      # Sets the stamper back to +nil+ to prepare for the next request.
+      def reset_stamper
+        Thread.current["#{self.to_s.downcase}_#{self.object_id}_stamper"] = nil
+      end
+    end
+  end
+end

data/lib/active_record/userstamp/version.rb

@@ -0,0 +1,4 @@
+module ActiveRecord; end
+module ActiveRecord::Userstamp
+  VERSION = '2.1.1'
+end

data/lib/activerecord/userstamp.rb

@@ -0,0 +1 @@
+require 'active_record/userstamp'

data/spec/controllers/posts_controller_spec.rb

@@ -0,0 +1,46 @@
+require 'rails_helper'
+
+RSpec.describe PostsController, type: :controller do
+  controller do
+  end
+
+  before(:each) do
+    reset_to_defaults
+  end
+
+  context 'when updating a Post' do
+    it 'sets the correct updater' do
+      request.session  = { person_id: @delynn.id }
+      post :update, id: @first_post.id, post: { title: 'Different' }
+
+      expect(response.status).to eq(200)
+      expect(controller.instance_variable_get(:@post).title).to eq('Different')
+      expect(controller.instance_variable_get(:@post).updater).to eq(@delynn)
+    end
+  end
+
+  context 'when handling multiple requests' do
+    def simulate_second_request
+      old_request_session = request.session
+      request.session = { person_id: @nicole.id }
+
+      post :update, id: @first_post.id, post: { title: 'Different Second'}
+      expect(controller.instance_variable_get(:@post).updater).to eq(@nicole)
+    ensure
+      request.session = old_request_session
+    end
+
+    it 'sets the correct updater' do
+      request.session = { person_id: @delynn.id }
+      get :edit, id: @first_post.id
+      expect(response.status).to eq(200)
+
+      simulate_second_request
+
+      post :update, id: @first_post.id, post: { title: 'Different' }
+      expect(response.status).to eq(200)
+      expect(controller.instance_variable_get(:@post).title).to eq('Different')
+      expect(controller.instance_variable_get(:@post).updater).to eq(@delynn)
+    end
+  end
+end

data/spec/controllers/users_controller_spec.rb

@@ -0,0 +1,41 @@
+require 'rails_helper'
+
+RSpec.describe UsersController, type: :controller do
+  controller do
+  end
+
+  before(:each) do
+    reset_to_defaults
+  end
+
+  context 'when updating a User' do
+    it 'sets the correct updater' do
+      request.session = { user_id: @hera.id }
+      patch :update, id: @hera.id, user: { name: 'Different'}
+
+      expect(response.status).to eq(200)
+      expect(controller.instance_variable_get(:@user).name).to eq('Different')
+      expect(controller.instance_variable_get(:@user).updater).to eq(@hera)
+    end
+  end
+
+  context 'when handling multiple requests' do
+    def simulate_second_request
+      old_request_session = request.session
+      request.session = { user_id: @zeus.id }
+
+      post :update, id: @hera.id, user: { name: 'Different Second' }
+      expect(controller.instance_variable_get(:@user).updater).to eq(@zeus)
+    ensure
+      request.session = old_request_session
+    end
+
+    it 'sets the correct updater' do
+      request.session = { user_id: @hera.id }
+      get :edit, id: @hera.id
+      expect(response.status).to eq(200)
+
+      simulate_second_request
+    end
+  end
+end

data/spec/coverage_helper.rb

@@ -0,0 +1,65 @@
+# Simultaneous code coverage reporting to Coveralls and Code Climate.
+# Latest version can be found at https://gist.github.com/lowjoel/6c2f2d3a08bb3786994f
+require 'simplecov'
+
+module CoverageHelper
+  class << self
+    # Helper to include Coveralls/Code Climate coverage, but not require developers to install the
+    # gem.
+    #
+    # @param [String] name The name of the module to require.
+    # @param [Proc] initializer The block to execute when the module is required successfully.
+    def load(name, &initializer)
+      old_formatter = SimpleCov.formatter
+      require name
+      initializer.call
+
+      merge_formatters(old_formatter, SimpleCov.formatter)
+    rescue LoadError => e
+      if e.path == name
+        puts format('Cannot find \'%s\', ignoring', name) if ENV['CI']
+      else
+        raise e
+      end
+    end
+
+    private
+
+    # Merge two SimpleCov formatters into a single MultiFormatter.
+    #
+    # This method is idempotent if the old and new formatters are the same.
+    def merge_formatters(old_formatter, new_formatter)
+      return if old_formatter == new_formatter
+
+      old_formatter = [*expand_formatter(old_formatter)]
+      new_formatter = [*expand_formatter(new_formatter)]
+      formatters = old_formatter + new_formatter
+
+      SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[*formatters]
+    end
+
+    # Extracts the formatters from a MultiFormatter so we do not nest them.
+    def expand_formatter(formatter)
+      return formatter unless formatter.is_a?(SimpleCov::Formatter::MultiFormatter)
+      formatter.formatters
+    end
+  end
+end
+
+if ENV['CI']
+  # Coveralls
+  CoverageHelper.load('coveralls') do
+    Coveralls.wear!('rails')
+  end
+
+  # Code Climate
+  CoverageHelper.load('codeclimate-test-reporter') do
+    CodeClimate::TestReporter.start
+  end
+
+  # Code coverage exclusions
+  SimpleCov.start do
+    # SimpleCov configuration
+    # add_filter '/lib/extensions/active_record/connection_adapters/table_definition.rb'
+  end
+end

data/spec/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Rails.application.load_tasks

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */