acts_as_list 0.7.4 → 1.1.0

data/Gemfile

@@ -1,23 +1,28 @@
 source "http://rubygems.org"
 
-gem "sqlite3", platforms: [:ruby]
-gem "activerecord-jdbcsqlite3-adapter", platforms: [:jruby]
-
-platforms :rbx do
-  gem "rubysl", "~> 2.0"
-  gem "rubinius-developer_tools"
-  gem "rubysl-test-unit"
-end
-
-# Specify your gem"s dependencies in acts_as_list-rails3.gemspec
 gemspec
 
 gem "rake"
 gem "appraisal"
-# Used to automatically generate changelog file
-gem "github_changelog_generator", "1.9.0"
+
+group :development do
+  gem "github_changelog_generator", "1.9.0"
+end
 
 group :test do
-	gem "minitest", "~> 5.0"
-  gem "test_after_commit", "~> 0.4.2"
+  gem "minitest", "~> 5.0"
+  gem "timecop"
+  gem "mocha"
+end
+
+group :sqlite do
+  gem "sqlite3", "~> 1.4"
+end
+
+group :postgresql do
+  gem "pg", "~> 1.2.0"
+end
+
+group :mysql do
+  gem "mysql2", "~> 0.5.0"
 end

data/README.md

@@ -1,9 +1,20 @@
-# ActsAsList
+# Acts As List
+
+## Build Status
+[![Build Status](https://travis-ci.org/brendon/acts_as_list.svg?branch=master)](https://travis-ci.org/brendon/acts_as_list)
+[![Gem Version](https://badge.fury.io/rb/acts_as_list.svg)](https://badge.fury.io/rb/acts_as_list)
 
 ## Description
 
 This `acts_as` extension provides the capabilities for sorting and reordering a number of objects in a list. The class that has this specified needs to have a `position` column defined as an integer on the mapped database table.
 
+## 0.8.0 Upgrade Notes
+
+There are a couple of changes of behaviour from `0.8.0` onwards:
+
+- If you specify `add_new_at: :top`, new items will be added to the top of the list like always. But now, if you specify a position at insert time: `.create(position: 3)`, the position will be respected. In this example, the item will end up at position `3` and will move other items further down the list. Before `0.8.0` the position would be ignored and the item would still be added to the top of the list. [#220](https://github.com/brendon/acts_as_list/pull/220)
+- `acts_as_list` now copes with disparate position integers (i.e. gaps between the numbers). There has been a change in behaviour for the `higher_items` method. It now returns items with the first item in the collection being the closest item to the reference item, and the last item in the collection being the furthest from the reference item (a.k.a. the first item in the list). [#223](https://github.com/brendon/acts_as_list/pull/223)
+
 ## Installation
 
 In your Gemfile:
@@ -20,27 +31,27 @@ At first, you need to add a `position` column to desired table:
 
     rails g migration AddPositionToTodoItem position:integer
     rake db:migrate
-    
-After that you can use `acts_as_list` method in the model: 
+
+After that you can use `acts_as_list` method in the model:
 
 ```ruby
 class TodoList < ActiveRecord::Base
   has_many :todo_items, -> { order(position: :asc) }
 end
-    
+
 class TodoItem < ActiveRecord::Base
   belongs_to :todo_list
   acts_as_list scope: :todo_list
 end
 
-todo_list = TodoList.find(...)    
+todo_list = TodoList.find(...)
 todo_list.todo_items.first.move_to_bottom
 todo_list.todo_items.last.move_higher
 ```
 
 ## Instance Methods Added To ActiveRecord Models
 
-You'll have a number of methods added to each instance of the ActiveRecord model that to which `acts_as_list` is added. 
+You'll have a number of methods added to each instance of the ActiveRecord model that to which `acts_as_list` is added.
 
 In `acts_as_list`, "higher" means further up the list (a lower `position`), and "lower" means further down the list (a higher `position`). That can be confusing, so it might make sense to add tests that validate that you're using the right method given your context.
 
@@ -70,9 +81,50 @@ In `acts_as_list`, "higher" means further up the list (a lower `position`), and
 - `list_item.lower_item`
 - `list_item.lower_items` will return all the items below `list_item` in the list (ordered by the position, ascending)
 
-## Notes
-If the `position` column has a default value, then there is a slight change in behavior, i.e if you have 4 items in the list, and you insert 1, with a default position 0, it would be pushed to the bottom of the list. Please look at the tests for this and some recent pull requests for discussions related to this.
+## Adding `acts_as_list` To An Existing Model
+As it stands `acts_as_list` requires position values to be set on the model before the instance methods above will work. Adding something like the below to your migration will set the default position. Change the parameters to order if you want a different initial ordering.
+
+```ruby
+class AddPositionToTodoItem < ActiveRecord::Migration
+  def change
+    add_column :todo_items, :position, :integer
+    TodoItem.order(:updated_at).each.with_index(1) do |todo_item, index|
+      todo_item.update_column :position, index
+    end
+  end
+end
+```
+
+If you are using the scope option things can get a bit more complicated. Let's say you have `acts_as_list scope: :todo_list`, you might instead need something like this:
+
+```ruby
+TodoList.all.each do |todo_list|
+  todo_list.todo_items.order(:updated_at).each.with_index(1) do |todo_item, index|
+    todo_item.update_column :position, index
+  end
+end
+```
+
+When using PostgreSQL, it is also possible to leave this migration up to the database layer. Inside of the `change` block you could write:
+
+```ruby
+ execute <<~SQL.squish
+   UPDATE todo_items
+   SET position = mapping.new_position
+   FROM (
+     SELECT
+       id,
+       ROW_NUMBER() OVER (
+         PARTITION BY todo_list_id
+         ORDER BY updated_at
+       ) as new_position
+     FROM todo_items
+   ) AS mapping
+   WHERE todo_items.id = mapping.id;
+ SQL
+```
 
+## Notes
 All `position` queries (select, update, etc.) inside gem methods are executed without the default scope (i.e. `Model.unscoped`), this will prevent nasty issues when the default scope is different from `acts_as_list` scope.
 
 The `position` column is set after validations are called, so you should not put a `presence` validation on the `position` column.
@@ -81,35 +133,170 @@ The `position` column is set after validations are called, so you should not put
 If you need a scope by a non-association field you should pass an array, containing field name, to a scope:
 ```ruby
 class TodoItem < ActiveRecord::Base
-  # `kind` is a plain text field (e.g. 'work', 'shopping', 'meeting'), not an association
-  acts_as_list scope: [:kind]
+  # `task_category` is a plain text field (e.g. 'work', 'shopping', 'meeting'), not an association
+  acts_as_list scope: [:task_category]
+end
+```
+
+You can also add multiple scopes in this fashion:
+```ruby
+class TodoItem < ActiveRecord::Base
+  belongs_to :todo_list
+  acts_as_list scope: [:task_category, :todo_list_id]
+end
+```
+
+Furthermore, you can optionally include a hash of fixed parameters that will be included in all queries:
+```ruby
+class TodoItem < ActiveRecord::Base
+  belongs_to :todo_list
+  # or `discarded_at` if using discard
+  acts_as_list scope: [:task_category, :todo_list_id, deleted_at: nil]
 end
 ```
 
+This is useful when using this gem in conjunction with the popular [acts_as_paranoid](https://github.com/ActsAsParanoid/acts_as_paranoid) or [discard](https://github.com/jhawthorn/discard) gems.
+
 ## More Options
 - `column`
-default: 'position'. Use this option if the column name in your database is different from position.
+default: `position`. Use this option if the column name in your database is different from position.
 - `top_of_list`
-default: '1'. Use this option to define the top of the list. Use 0 to make the collection act more like an array in its indexing.
+default: `1`. Use this option to define the top of the list. Use 0 to make the collection act more like an array in its indexing.
 - `add_new_at`
-default: ':bottom'. Use this option to specify whether objects get added to the :top or :bottom of the list. `nil` will result in new items not being added to the list on create, i.e, position will be kept nil after create.
+default: `:bottom`. Use this option to specify whether objects get added to the `:top` or `:bottom` of the list. `nil` will result in new items not being added to the list on create, i.e, position will be kept nil after create.
+- `touch_on_update`
+default: `true`. Use `touch_on_update: false` if you don't want to update the timestamps of the associated records.
+- `sequential_updates`
+Specifies whether insert_at should update objects positions during shuffling one by one to respect position column unique not null constraint. Defaults to true if position column has unique index, otherwise false. If constraint is `deferrable initially deferred` (PostgreSQL), overriding it with false will speed up insert_at.
+
+## Disabling temporarily
+
+If you need to temporarily disable `acts_as_list` during specific operations such as mass-update or imports:
+```ruby
+TodoItem.acts_as_list_no_update do
+  perform_mass_update
+end
+```
+In an `acts_as_list_no_update` block, all callbacks are disabled, and positions are not updated. New records will be created with
+ the default value from the database. It is your responsibility to correctly manage `positions` values.
+
+You can also pass an array of classes as an argument to disable database updates on just those classes. It can be any ActiveRecord class that has acts_as_list enabled.
+```ruby
+class TodoList < ActiveRecord::Base
+  has_many :todo_items, -> { order(position: :asc) }
+  acts_as_list
+end
+
+class TodoItem < ActiveRecord::Base
+  belongs_to :todo_list
+  has_many :todo_attachments, -> { order(position: :asc) }
+
+  acts_as_list scope: :todo_list
+end
+
+class TodoAttachment < ActiveRecord::Base
+  belongs_to :todo_list
+  acts_as_list scope: :todo_item
+end
+
+TodoItem.acts_as_list_no_update([TodoAttachment]) do
+  TodoItem.find(10).update(position: 2)
+  TodoAttachment.find(10).update(position: 1)
+  TodoAttachment.find(11).update(position: 2)
+  TodoList.find(2).update(position: 3) # For this instance the callbacks will be called because we haven't passed the class as an argument
+end
+```
+
+## Troubleshooting Database Deadlock Errors
+When using this gem in an app with a high amount of concurrency, you may see "deadlock" errors raised by your database server.
+It's difficult for the gem to provide a solution that fits every app.
+Here are some steps you can take to mitigate and handle these kinds of errors.
+
+### 1) Use the Most Concise API
+One easy way to reduce deadlocks is to use the most concise gem API available for what you want to accomplish.
+In this specific example, the more concise API for creating a list item at a position results in one transaction instead of two,
+and it issues fewer SQL statements. Issuing fewer statements tends to lead to faster transactions.
+Faster transactions are less likely to deadlock.
+
+Example:
+```ruby
+# Good
+TodoItem.create(todo_list: todo_list, position: 1)
+
+# Bad
+item = TodoItem.create(todo_list: todo_list)
+item.insert_at(1)
+```
+
+### 2) Rescue then Retry
+Deadlocks are always a possibility when updating tables rows concurrently.
+The general advice from MySQL documentation is to catch these errors and simply retry the transaction; it will probably succeed on another attempt. (see [How to Minimize and Handle Deadlocks](https://dev.mysql.com/doc/refman/8.0/en/innodb-deadlocks-handling.html))
+Retrying transactions sounds simple, but there are many details that need to be chosen on a per-app basis:
+How many retry attempts should be made?
+Should there be a wait time between attempts?
+What _other_ statements were in the transaction that got rolled back?
+
+Here a simple example of rescuing from deadlock and retrying the operation:
+*  `ActiveRecord::Deadlocked` is available in Rails >= 5.1.0.
+* If you have Rails < 5.1.0, you will need to rescue `ActiveRecord::StatementInvalid` and check `#cause`.
+```ruby
+  attempts_left = 2
+  while attempts_left > 0
+    attempts_left -= 1
+    begin
+      TodoItem.transaction do
+        TodoItem.create(todo_list: todo_list, position: 1)
+      end
+      attempts_left = 0
+    rescue ActiveRecord::Deadlocked
+      raise unless attempts_left > 0
+    end
+  end
+```
+
+You can also use the approach suggested in this StackOverflow post:
+https://stackoverflow.com/questions/4027659/activerecord3-deadlock-retry
+
+### 3) Lock Parent Record
+In addition to reacting to deadlocks, it is possible to reduce their frequency with more pessimistic locking.
+This approach uses the parent record as a mutex for the entire list.
+This kind of locking is very effective at reducing the frequency of deadlocks while updating list items.
+However, there are some things to keep in mind:
+* This locking pattern needs to be used around *every* call that modifies the list; even if it does not reorder list items.
+* This locking pattern effectively serializes operations on the list. The throughput of operations on the list will decrease.
+* Locking the parent record may lead to deadlock elsewhere if some other code also locks the parent table.
+
+Example:
+```ruby
+todo_list = TodoList.create(name: "The List")
+todo_list.with_lock do
+  item = TodoItem.create(description: "Buy Groceries", todo_list: todo_list, position: 1)
+end
+```
 
 ## Versions
+Version `0.9.0` adds `acts_as_list_no_update` (https://github.com/brendon/acts_as_list/pull/244) and compatibility with not-null and uniqueness constraints on the database (https://github.com/brendon/acts_as_list/pull/246). These additions shouldn't break compatibility with existing implementations.
+
+As of version `0.7.5` Rails 5 is supported.
+
 All versions `0.1.5` onwards require Rails 3.0.x and higher.
 
-## Build Status
-[![Build Status](https://secure.travis-ci.org/swanandp/acts_as_list.png)](https://secure.travis-ci.org/swanandp/acts_as_list)
+## A note about data integrity
+
+We often hear complaints that `position` values are repeated, incorrect etc. For example, #254. To ensure data integrity, you should rely on your database. There are two things you can do:
+
+1. Use constraints.  If you model `Item` that `belongs_to` an `Order`, and it has a `position` column, then add a unique constraint on `items` with `[:order_id, :position]`.  Think of it as a list invariant. What are the properties of your list that don't change no matter how many items you have in it?  One such propery is that each item has a distinct position. Another _could be_ that position is always greater than 0. It is strongly recommended that you rely on your database to enforce these invariants or constraints. Here are the docs for [PostgreSQL](https://www.postgresql.org/docs/9.5/static/ddl-constraints.html) and [MySQL](https://dev.mysql.com/doc/refman/8.0/en/alter-table.html).
+2. Use mutexes or row level locks. At its heart the duplicate problem is that of handling concurrency. Adding a contention resolution mechanism like locks will solve it to some extent.  But it is not a solution or replacement for constraints.  Locks are also prone to deadlocks.
+
+As a library, `acts_as_list` may not always have all the context needed to apply these tools. They are much better suited at the application level.
 
-## Workflow Status
-[![WIP Issues](https://badge.waffle.io/swanandp/acts_as_list.png)](http://waffle.io/swanandp/acts_as_list)
 
 ## Roadmap
 
 1. Sort based feature
-2. Rails 4 compatibility and bye bye Rails 2! Older versions would of course continue to work with Rails 2, but there won't be any support on those.
 
 ## Contributing to `acts_as_list`
- 
+
 - Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
 - Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
 - Fork the project

data/Rakefile

@@ -10,8 +10,8 @@ task default: :test
 
 desc "Test the acts_as_list plugin."
 Rake::TestTask.new(:test) do |t|
-  t.libs << "lib" << "test"
-  t.pattern = "test/**/test_*.rb"
+  t.libs << "test" << "."
+  t.test_files = Rake::FileList["test/**/test_*.rb"]
   t.verbose = false
 end
 
@@ -38,5 +38,5 @@ end
 require 'github_changelog_generator/task'
 GitHubChangelogGenerator::RakeTask.new :changelog do |config|
   config.project = 'acts_as_list'
-  config.user = 'swanandp'
-end
+  config.user = 'brendon'
+end

data/acts_as_list.gemspec

@@ -7,23 +7,28 @@ Gem::Specification.new do |s|
   s.name                  = "acts_as_list"
   s.version               = ActiveRecord::Acts::List::VERSION
   s.platform              = Gem::Platform::RUBY
-  s.authors               = ["David Heinemeier Hansson", "Swanand Pagnis", "Quinn Chaffee"]
-  s.email                 = ["swanand.pagnis@gmail.com"]
-  s.homepage              = "http://github.com/swanandp/acts_as_list"
+  s.authors               = ["Swanand Pagnis", "Brendon Muir"]
+  s.email                 = %w(swanand.pagnis@gmail.com brendon@spikeatschool.co.nz)
+  s.homepage              = "http://github.com/brendon/acts_as_list"
   s.summary               = "A gem adding sorting, reordering capabilities to an active_record model, allowing it to act as a list"
   s.description           = 'This "acts_as" extension provides the capabilities for sorting and reordering a number of objects in a list. The class that has this specified needs to have a "position" column defined as an integer on the mapped database table.'
   s.license               = "MIT"
-  s.rubyforge_project     = "acts_as_list"
-  s.required_ruby_version = ">= 1.9.2"
+  s.required_ruby_version = ">= 2.4.7"
+
+  if s.respond_to?(:metadata)
+    s.metadata['changelog_uri']   = 'https://github.com/brendon/acts_as_list/blob/master/CHANGELOG.md'
+    s.metadata['source_code_uri'] = 'https://github.com/brendon/acts_as_list'
+    s.metadata['bug_tracker_uri'] = 'https://github.com/brendon/acts_as_list/issues'
+  end
 
   # Load Paths...
-  s.files                 = `git ls-files`.split("\n")
-  s.test_files            = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables           = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
-  s.require_paths         = ["lib"]
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map {|f| File.basename(f)}
+  s.require_paths = ["lib"]
 
 
   # Dependencies (installed via "bundle install")
-  s.add_dependency("activerecord", [">= 3.0"])
-  s.add_development_dependency("bundler", [">= 1.0.0"])
+  s.add_dependency "activerecord", ">= 4.2"
+  s.add_development_dependency "bundler", ">= 1.0.0"
 end

data/gemfiles/rails_4_2.gemfile

@@ -2,22 +2,31 @@
 
 source "http://rubygems.org"
 
-gem "sqlite3", :platforms => [:ruby]
-gem "activerecord-jdbcsqlite3-adapter", :platforms => [:jruby]
 gem "rake"
 gem "appraisal"
-gem "github_changelog_generator", "1.9.0"
-gem "activerecord", "~> 4.2.1"
+gem "activerecord", "~> 4.2.0"
+
+group :development do
+  gem "github_changelog_generator", "1.9.0"
+end
 
 group :test do
   gem "minitest", "~> 5.0"
+  gem "timecop"
+  gem "mocha"
   gem "test_after_commit", "~> 0.4.2"
 end
 
-platforms :rbx do
-  gem "rubysl", "~> 2.0"
-  gem "rubinius-developer_tools"
-  gem "rubysl-test-unit"
+group :sqlite do
+  gem "sqlite3", "~> 1.3.13"
+end
+
+group :postgresql do
+  gem "pg", "~> 0.18.4"
+end
+
+group :mysql do
+  gem "mysql2", "~> 0.4.0"
 end
 
-gemspec :path => "../"
+gemspec path: "../"

data/gemfiles/rails_5_0.gemfile

@@ -0,0 +1,31 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rake"
+gem "appraisal"
+gem "activerecord", "~> 5.0.0"
+
+group :development do
+  gem "github_changelog_generator", "1.9.0"
+end
+
+group :test do
+  gem "minitest", "~> 5.0"
+  gem "timecop"
+  gem "mocha"
+end
+
+group :sqlite do
+  gem "sqlite3", "~> 1.3.13"
+end
+
+group :postgresql do
+  gem "pg", "~> 1.2.0"
+end
+
+group :mysql do
+  gem "mysql2", "~> 0.5.0"
+end
+
+gemspec path: "../"

data/gemfiles/rails_5_1.gemfile

@@ -0,0 +1,31 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rake"
+gem "appraisal"
+gem "activerecord", "~> 5.1.0"
+
+group :development do
+  gem "github_changelog_generator", "1.9.0"
+end
+
+group :test do
+  gem "minitest", "~> 5.0"
+  gem "timecop"
+  gem "mocha"
+end
+
+group :sqlite do
+  gem "sqlite3", "~> 1.4"
+end
+
+group :postgresql do
+  gem "pg", "~> 1.2.0"
+end
+
+group :mysql do
+  gem "mysql2", "~> 0.5.0"
+end
+
+gemspec path: "../"

data/gemfiles/rails_5_2.gemfile

@@ -0,0 +1,31 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rake"
+gem "appraisal"
+gem "activerecord", "~> 5.2.0"
+
+group :development do
+  gem "github_changelog_generator", "1.9.0"
+end
+
+group :test do
+  gem "minitest", "~> 5.0"
+  gem "timecop"
+  gem "mocha"
+end
+
+group :sqlite do
+  gem "sqlite3", "~> 1.4"
+end
+
+group :postgresql do
+  gem "pg", "~> 1.2.0"
+end
+
+group :mysql do
+  gem "mysql2", "~> 0.5.0"
+end
+
+gemspec path: "../"

data/gemfiles/rails_6_0.gemfile

@@ -0,0 +1,31 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rake"
+gem "appraisal"
+gem "activerecord", "~> 6.0.0"
+
+group :development do
+  gem "github_changelog_generator", "1.9.0"
+end
+
+group :test do
+  gem "minitest", "~> 5.0"
+  gem "timecop"
+  gem "mocha"
+end
+
+group :sqlite do
+  gem "sqlite3", "~> 1.4"
+end
+
+group :postgresql do
+  gem "pg", "~> 1.2.0"
+end
+
+group :mysql do
+  gem "mysql2", "~> 0.5.0"
+end
+
+gemspec path: "../"

data/gemfiles/rails_6_1.gemfile

@@ -0,0 +1,31 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rake"
+gem "appraisal"
+gem "activerecord", "~> 6.1.0"
+
+group :development do
+  gem "github_changelog_generator", "1.9.0"
+end
+
+group :test do
+  gem "minitest", "~> 5.0"
+  gem "timecop"
+  gem "mocha"
+end
+
+group :sqlite do
+  gem "sqlite3", "~> 1.4"
+end
+
+group :postgresql do
+  gem "pg", "~> 1.2.0"
+end
+
+group :mysql do
+  gem "mysql2", "~> 0.5.0"
+end
+
+gemspec path: "../"

data/gemfiles/rails_7_0.gemfile

@@ -0,0 +1,31 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rake"
+gem "appraisal"
+gem "activerecord", "~> 7.0.0"
+
+group :development do
+  gem "github_changelog_generator", "~> 1.16.0"
+end
+
+group :test do
+  gem "minitest", "~> 5.0"
+  gem "timecop"
+  gem "mocha"
+end
+
+group :sqlite do
+  gem "sqlite3", "~> 1.4"
+end
+
+group :postgresql do
+  gem "pg", "~> 1.3.0"
+end
+
+group :mysql do
+  gem "mysql2", "~> 0.5.0"
+end
+
+gemspec path: "../"

data/init.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 $:.unshift "#{File.dirname(__FILE__)}/lib"
 require "acts_as_list"

data/lib/acts_as_list/active_record/acts/active_record.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+ActiveSupport.on_load :active_record do
+  extend ActiveRecord::Acts::List::ClassMethods
+end

data/lib/acts_as_list/active_record/acts/add_new_at_method_definer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveRecord::Acts::List::AddNewAtMethodDefiner #:nodoc:
+  def self.call(caller_class, add_new_at)
+    caller_class.class_eval do
+      define_method :add_new_at do
+        add_new_at
+      end
+    end
+  end
+end

data/lib/acts_as_list/active_record/acts/aux_method_definer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveRecord::Acts::List::AuxMethodDefiner #:nodoc:
+  def self.call(caller_class)
+    caller_class.class_eval do
+      define_method :acts_as_list_class do
+        caller_class
+      end
+    end
+  end
+end