nay-record_with_operator 0.0.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [name of plugin creator]
+
+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.rdoc

@@ -0,0 +1,64 @@
+= RecordWithOperator
+
+== Introduction
+
+RecordWithOperator is a rails plugin that makes your all active record models to be saved or logically deleted with created_by, updated_by, deleted_by automatically.
+Also it makes creator, updater, deleter association (belongs_to) if the class has created_by, updated_by, deleted_by.
+
+You need to set 'operator' (it may be an User object) to your model object at first.
+Once you have set an operator, it will be copied to objects in the association collection, so it might be enough to set an operator per request.
+Operators are also useful for your access control features on model's side.
+To set an operator, simply use operator= or get objects by find method with :for option.
+
+The logical deletion function itself is out of this plugin's scope.
+This plugin assumes that the logical deletion is kicked by record.destory.
+
+== Installation
+
+  gem install nay-record_with_operator --source http://gems.github.com
+
+Or, you can install it in vender/plugins.
+
+  > ./script/plugin install git://github.com/nay/record_with_operator.git
+
+
+== Rails Configration
+
+In config/environment.rb:
+
+  Rails::Initializer.run do |config|
+    config.gem 'nay-record_with_operator', :lib => 'record_with_operator',
+      :source => 'http://gems.github.com'
+  end
+
+== Example
+
+Create a new note object with current_user:
+
+ note = Note.create(:body => "This is my first note.", :operator => current_user)
+ # note.operator will be current_user
+ # note.created_by will be current_user.id
+
+Get note objects with current_user:
+
+ notes = Note.find(:all, :for => current_user)
+ # notes.first.operator will be current_user
+ # notes.find_by_body("This is my first note.").operator will be current_user
+
+Create note's comments:
+
+ note = Note.find(params[:id], :for => current_user)
+ note.comments.create!(:body => params[:comment_body])
+ # comment's operator will be automatically set and used as created_by
+
+== Configuration
+
+You can change the operator's class name by setting RecordWithOperator.config[:user_class_name].
+The default is 'User'.
+Note that it is required to change the value before the model's creator/updater/deleter is firstly called.
+For example, you can write the code under config/initializers.
+
+  RecordWithOperator.config[:user_class_name] = "AdminUser"
+
+
+Copyright (c) 2009 Yasuko Ohba, released under the MIT license

data/Rakefile

@@ -0,0 +1,71 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+NAME = "record_with_operator"
+AUTHOR = "Yasuko Ohba"
+EMAIL = "y.ohba@everyleaf.com"
+DESCRIPTION = "Rails plugin to set created_by, updated_by, deleted_by to ActiveRecord objects. Supports associations."
+GITHUB_PROJECT = "record_with_operator"
+HOMEPAGE = "http://github.com/nay/#{GITHUB_PROJECT}/tree"
+BIN_FILES = %w( )
+VER = "0.0.2"
+CLEAN.include ['pkg']
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the record_with_operator plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the record_with_operator plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RecordWithOperator'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = VER
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.rdoc", "MIT-LICENSE"]
+  s.rdoc_options += ['--line-numbers', '--inline-source']
+  s.summary = DESCRIPTION
+  s.description = DESCRIPTION
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.executables = BIN_FILES
+  s.bindir = "bin"
+  s.require_path = "lib"
+  s.test_files = Dir["test/*"]
+
+  s.add_dependency('activerecord', '>=2.2.0')
+  
+  s.files = %w(README.rdoc Rakefile MIT-LICENSE) +
+    %w(install.rb uninstall.rb init.rb) +
+    Dir.glob("{bin,doc,lib,tasks,test}/**/*")
+
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.need_tar = true
+  p.gem_spec = spec
+end
+
+desc 'Update gem spec'
+task :gemspec do
+  open("#{NAME}.gemspec", "w").write spec.to_ruby
+end

data/init.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.instance_eval{include RecordWithOperator} unless ActiveRecord::Base.include?(RecordWithOperator)

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/association_with_operator.rb

@@ -0,0 +1,24 @@
+module AssociationWithOperator
+
+  def find(*args)
+    results = super
+    if results.kind_of? Array
+      results.each{|r| r.operator = proxy_owner.operator}
+    else
+      results.operator = proxy_owner.operator
+    end
+    results
+  end
+
+
+  def method_missing(method, *args)
+    results = super
+    if results.respond_to?(:operator=)
+      results.operator= proxy_owner.operator
+    elsif results.kind_of? Array
+      results.each{|r| r.operator = proxy_owner.operator if r.respond_to?(:operator=)}
+    end
+    results
+  end
+
+end

data/lib/record_with_operator.rb

@@ -0,0 +1,116 @@
+module RecordWithOperator
+  def self.config
+    @config ||= {:user_class_name => "User"}
+    @config
+  end
+
+  attr_accessor :operator
+
+  def self.included(base)
+    class << base
+      def has_many_with_operator(*args, &extension)
+        options = args.extract_options!
+        # add AssociationWithOprator to :extend
+        if options[:extend]
+          options[:extend] = [options[:extend]] unless options[:extend].kind_of? Array
+          options[:extend] << AssociationWithOperator
+        else
+          options[:extend] = AssociationWithOperator
+        end
+        # add :set_operator to :before_add
+        if options[:before_add]
+          options[:before_add] = [options[:before_add]] unless options[:before_add].kind_of? Array
+          options[:before_add] << :set_operator
+        else
+          options[:before_add] = :set_operator
+        end
+        args << options
+        has_many_without_operator(*args, &extension)
+      end
+      alias_method_chain :has_many, :operator
+
+      def find_with_for(*args)
+        options = args.extract_options!
+        operator = options.delete(:for)
+        args << options
+        results = find_without_for(*args)
+        if operator
+          if results.kind_of? Array
+            results.each{|r| r.operator = operator}
+          else
+            results.operator = operator
+          end
+        end
+        results
+      end
+
+      alias_method_chain :find, :for
+
+      def validate_find_options_with_for(options)
+        if options
+          options = options.dup
+          options.delete(:for)
+        end
+        validate_find_options_without_for(options)
+      end
+
+      alias_method_chain :validate_find_options, :for
+    end
+
+    base.before_create :set_created_by
+    base.before_save :set_updated_by
+    base.before_destroy :set_deleted_by
+
+  end
+
+  def respond_to?(name, priv=false)
+    case name.to_sym
+    when :creator
+      respond_to? :created_by
+    when :updater
+      respond_to? :updated_by
+    when :deleter
+      respond_to? :deleted_by
+    else
+      super
+    end
+  end
+
+  private
+  def set_operator(child)
+    child.operator = self.operator
+  end
+
+  def method_missing(method, *args)
+    return super unless respond_to?(method)
+    case method.to_sym
+    when :creator
+      self.class.belongs_to :creator, :foreign_key => "created_by", :class_name => RecordWithOperator.config[:user_class_name]
+      send(method, *args)
+    when :updater
+      self.class.belongs_to :updater, :foreign_key => "updated_by", :class_name => RecordWithOperator.config[:user_class_name]
+      send(method, *args)
+    when :deleter
+      self.class.belongs_to :deletor, :foreign_key => "deleted_by", :class_name => RecordWithOperator.config[:user_class_name]
+      send(method, *args)
+    else
+      super
+    end
+  end
+
+  def set_created_by
+    return unless respond_to?(:created_by=) && operator
+    self.created_by = operator.id
+  end
+
+  def set_updated_by
+    return unless respond_to?(:updated_by=) && operator
+    self.updated_by = operator.id
+  end
+
+  def set_deleted_by
+    return unless respond_to?(:deleted_by=) && operator
+    self.updated_by = operator.id
+  end
+
+end

data/tasks/record_with_operator_tasks.rake

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

data/test/database.yml

@@ -0,0 +1,18 @@
+sqlite:
+  :adapter: sqlite
+  :dbfile: record_with_operator_plugin.sqlite.db
+sqlite3:
+  :adapter: sqlite3
+  :dbfile: record_with_operator_plugin.sqlite3.db
+postgresql:
+  :adapter: postgresql
+  :username: postgres
+  :password: postgres
+  :database: record_with_operator_plugin_test
+  :min_messages: ERROR
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username:
+  :password:
+  :database: record_with_operator_plugin_test

data/test/record_with_operator_test.rb

@@ -0,0 +1,206 @@
+require 'test_helper'
+
+class User < ActiveRecord::Base
+end
+
+class NoteWithUser < ActiveRecord::Base
+  set_table_name "notes"
+  has_many :memos, :class_name => "MemoWithUser", :foreign_key => "note_id"
+
+  named_scope :new_arrivals, {:order => "updated_at desc"}
+
+  def destroy_with_deleted_at
+    NoteWithUser.update_all("deleted_at = '#{Time.now.to_s(:db)}'", "id = #{self.id}")
+  end
+  alias_method_chain :destroy, :deleted_at
+  def destory!
+    destory_without_deleted_at
+  end
+
+  def deleted?
+    self.deleted_at <= Time.now
+  end
+end
+
+class SimpleNoteWithUser < ActiveRecord::Base
+  set_table_name "simple_notes"
+end
+
+class MemoWithUser < ActiveRecord::Base
+  set_table_name "memos"
+
+  named_scope :new_arrivals, {:order => "updated_at desc"}
+end
+
+class UpdaterNoteWithUser < ActiveRecord::Base
+  set_table_name "updater_notes"
+
+end
+
+class DeleterNoteWithUser < ActiveRecord::Base
+  set_table_name "deleter_notes"
+
+end
+
+class RecordWithOperatorTest < ActiveSupport::TestCase
+  def setup
+    RecordWithOperator.config[:user_class_name] = "User"
+    @user1 = User.create!(:name => "user1")
+    @user2 = User.create!(:name => "user2")
+    @note_created_by_user1 = NoteWithUser.create!(:body => "test", :operator => @user1)
+  end
+
+  # creator/updater/deleter association operation
+
+  def test_note_should_be_respond_to_creator
+    assert NoteWithUser.new.respond_to? :creator
+  end
+
+  def test_simple_note_should_not_be_respond_to_creator
+    assert_equal false, SimpleNoteWithUser.new.respond_to?(:creator)
+  end
+
+  def test_note_should_be_respond_to_updater
+    assert NoteWithUser.new.respond_to? :updater
+  end
+
+  def test_simple_note_should_not_be_respond_to_updater
+    assert_equal false, SimpleNoteWithUser.new.respond_to?(:updater)
+  end
+
+  def test_note_should_be_respond_to_deleter
+    assert NoteWithUser.new.respond_to? :deleter
+  end
+
+  def test_simple_note_should_not_be_respond_to_deleter
+    assert_equal false, SimpleNoteWithUser.new.respond_to?(:deleter)
+  end
+
+  # test updater without creater, deleter
+  def test_updater_note_should_not_be_respond_to_creater
+    assert_equal false, UpdaterNoteWithUser.new.respond_to?(:creater)
+  end
+  def test_updater_note_should_be_respond_to_updater
+    assert UpdaterNoteWithUser.new.respond_to? :updater
+  end
+  def test_updater_note_should_not_be_respond_to_deleter
+    assert_equal false, UpdaterNoteWithUser.new.respond_to?(:deleter)
+  end
+
+  # test deleter without create, updater
+  def test_deleter_note_should_not_be_respond_to_creater
+    assert_equal false, DeleterNoteWithUser.new.respond_to?(:creater)
+  end
+  def test_deleter_note_should_not_be_respond_to_updater
+    assert_equal false, DeleterNoteWithUser.new.respond_to?(:updater)
+  end
+  def test_deleter_note_should_be_respond_to_deleter
+    assert DeleterNoteWithUser.new.respond_to?(:deleter)
+  end
+
+  # find with :for
+  def test_note_should_be_found_with_for
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    assert_equal(@user2, note.operator)
+  end
+
+  def test_note_should_be_found_with_for_through_named_scope
+    note = NoteWithUser.new_arrivals.find(@note_created_by_user1.id, :for => @user2)
+    assert_equal(@user2, note.operator)
+  end
+
+  # save or destory with xxxx_by and can get as a creator/updator/deleter
+
+  def test_note_should_be_created_with_operator
+    assert_equal @user1, @note_created_by_user1.operator
+  end
+
+  def test_note_should_be_created_with_created_by_and_updated_by
+    assert_equal @user1.id, @note_created_by_user1.created_by
+    assert_equal @user1.id, @note_created_by_user1.updated_by
+    @note_created_by_user1.reload
+    assert_equal @user1.id, @note_created_by_user1.created_by
+    assert_equal @user1.id, @note_created_by_user1.updated_by
+    assert_equal @user1, @note_created_by_user1.creator
+    assert_equal @user1, @note_created_by_user1.updater
+  end
+
+  def test_note_should_be_updated_with_updated_by
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    note.body = "changed"
+    note.save!
+    assert_equal(@user2.id, note.updated_by)
+    note.reload
+    assert_equal(@user2.id, note.updated_by)
+  end
+
+  def test_note_should_be_destroyed_with_deleted_by
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    note.destroy # logically
+    note.reload
+    raise "not deleted" unless note.deleted?
+    assert @user2.id, note.deleted_by
+  end
+
+  # reload
+  def test_reload_should_not_change_operator
+    @note_created_by_user1.reload
+    assert_equal @user1, @note_created_by_user1.operator
+  end
+  
+
+  # has_many Association Test
+  def test_builded_memo_should_have_operator
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    memo = note.memos.build(:body => "memo")
+    assert_equal @user2, memo.operator
+  end
+
+  def test_created_memo_should_have_operator_and_created_by
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    memo = note.memos.create(:body => "memo")
+    assert_equal false, memo.new_record?
+    assert_equal @user2, memo.operator
+    assert_equal @user2.id, memo.created_by
+  end
+
+  def test_auto_found_memo_should_have_operator
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    note.memos.create!(:body => "memo")
+    assert_equal @user2, note.memos(true).first.operator
+  end
+
+  def test_manualy_found_memo_should_have_operator
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    note.memos.create!(:body => "memo")
+    assert_equal @user2, note.memos.find(:first).operator
+  end
+
+  def test_dynamically_found_memo_should_have_operator
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    note.memos.create!(:body => "memo")
+    assert_equal @user2, note.memos.find_by_body("memo").operator
+  end
+
+  def test_dynamically_found_memos_should_have_operator
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    note.memos.create!(:body => "memo")
+    assert note.memos.find_all_by_body("memo").all?{|m| m.operator == @user2}
+  end
+
+
+  def test_found_memo_through_named_scope_should_have_operator
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    note.memos.create!(:body => "memo")
+    assert_equal @user2, note.memos.new_arrivals.first.operator
+  end
+
+
+  def test_dynamically_found_memo_through_named_scope_should_have_operator
+    note = NoteWithUser.find(@note_created_by_user1.id, :for => @user2)
+    note.memos.create!(:body => "memo")
+    assert_equal @user2, note.memos.new_arrivals.find_by_body("memo").operator
+  end
+
+
+end

data/test/record_with_operator_user_class_name_test.rb

@@ -0,0 +1,59 @@
+
+require 'test_helper'
+
+class NoteWithAdminUser < ActiveRecord::Base
+  set_table_name "notes"
+
+  def destroy_with_deleted_at
+    NoteWithAdminUser.update_all("deleted_at = '#{Time.now.to_s(:db)}'", "id = #{self.id}")
+  end
+  alias_method_chain :destroy, :deleted_at
+  def destory!
+    destory_without_deleted_at
+  end
+
+  def deleted?
+    self.deleted_at <= Time.now
+  end
+end
+
+class AdminUser < ActiveRecord::Base
+  set_table_name "users"
+end
+
+class RecordWithOperatorUserClassNameTest < ActiveSupport::TestCase
+  def setup
+    RecordWithOperator.config[:user_class_name] = "AdminUser"
+    @user1 = AdminUser.create!(:name => "user1")
+    @user2 = AdminUser.create!(:name => "user2")
+    @note_created_by_user1 = NoteWithAdminUser.create!(:body => "test", :operator => @user1)
+  end
+
+  def test_note_should_be_created_with_operator
+    assert_equal @user1, @note_created_by_user1.operator
+  end
+
+  def test_note_should_be_created_with_created_by_and_updated_by
+    assert_equal @user1.id, @note_created_by_user1.created_by
+    assert_equal @user1.id, @note_created_by_user1.updated_by
+    @note_created_by_user1.reload
+    assert_equal @user1.id, @note_created_by_user1.created_by
+    assert_equal @user1.id, @note_created_by_user1.updated_by
+    assert @note_created_by_user1.creator.kind_of?(AdminUser)
+  end
+
+  def test_note_should_be_found_with_for
+    note = NoteWithAdminUser.find(@note_created_by_user1.id, :for => @user2)
+    assert_equal(@user2, note.operator)
+  end
+
+  def test_note_should_be_updated_with_updated_by
+    note = NoteWithAdminUser.find(@note_created_by_user1.id, :for => @user2)
+    note.body = "changed"
+    note.save!
+    assert_equal(@user2.id, note.updated_by)
+    note.reload
+    assert_equal(@user2.id, note.updated_by)
+  end
+
+end

data/test/schema.rb

@@ -0,0 +1,49 @@
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table :simple_notes, :force => true do |t|
+    t.column :body, :text
+  end
+
+  create_table :creator_notes, :force => true do |t|
+    t.column :body, :text
+    t.column :created_by, :integer
+    t.column :created_at, :datetime
+  end
+
+  create_table :updater_notes, :force => true do |t|
+    t.column :body, :text
+    t.column :updated_by, :integer
+    t.column :updated_at, :datetime
+  end
+
+  create_table :deleter_notes, :force => true do |t|
+    t.column :body, :text
+    t.column :deleted_by, :integer
+    t.column :deleted_at, :datetime
+  end
+
+  create_table :notes, :force => true do |t|
+    t.column :body, :text
+    t.column :created_by, :integer
+    t.column :created_at, :datetime
+    t.column :updated_by, :integer
+    t.column :updated_at, :datetime
+    t.column :deleted_by, :integer
+    t.column :deleted_at, :datetime
+  end
+
+  create_table :memos, :force => true do |t|
+    t.column :note_id, :integer
+    t.column :body, :text
+    t.column :created_by, :integer
+    t.column :created_at, :datetime
+    t.column :updated_by, :integer
+    t.column :updated_at, :datetime
+    t.column :deleted_by, :integer
+    t.column :deleted_at, :datetime
+  end
+
+  create_table :users, :force => true do |t|
+    t.column :name, :string
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../../config/environment.rb'))
+require 'test/unit'
+require 'active_support'
+require 'active_support/test_case'
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(config['mysql'])
+
+load(File.dirname(__FILE__) + "/schema.rb")

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: nay-record_with_operator
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Yasuko Ohba
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-20 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.0
+    version: 
+description: Rails plugin to set created_by, updated_by, deleted_by to ActiveRecord objects. Supports associations.
+email: y.ohba@everyleaf.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+files: 
+- README.rdoc
+- Rakefile
+- MIT-LICENSE
+- install.rb
+- uninstall.rb
+- init.rb
+- lib/association_with_operator.rb
+- lib/record_with_operator.rb
+- tasks/record_with_operator_tasks.rake
+- test/database.yml
+- test/record_with_operator_test.rb
+- test/record_with_operator_user_class_name_test.rb
+- test/schema.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/nay/record_with_operator/tree
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Rails plugin to set created_by, updated_by, deleted_by to ActiveRecord objects. Supports associations.
+test_files: 
+- test/database.yml
+- test/record_with_operator_test.rb
+- test/record_with_operator_user_class_name_test.rb
+- test/schema.rb
+- test/test_helper.rb