positioning 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d2088ce4125fed14b6422ec4e02e1ca5a203d724f0cfaafc043ff7b7c0465a03
+  data.tar.gz: 9aa3da89865ab6e2336bcb00a7259b97bd69bc3c639b0495c551a1feb33c24fe
+SHA512:
+  metadata.gz: 737adf268dda74000333e2f3d316c58d162d13385a219e3b48668fffb04a7a0b55f197dba5d19b58b2f32b8f1496c10c8dc432b293fffde1142053719facfdc2
+  data.tar.gz: 8165738f13801f4d8bb8f749c19afe0939a9d6b2e5907038c9b10d7777f7af6daf6f463eac1fc981288c3fba21c69ce19bfa722988d814cdac68509926a40233

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard
+ruby_version: 3.0

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-02-07
+
+- Initial release

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in positioning.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"
+
+gem "standard", "~> 1.3"

data/Gemfile.lock

@@ -0,0 +1,109 @@
+PATH
+  remote: .
+  specs:
+    positioning (0.1.0)
+      activerecord (>= 6.1)
+      activesupport (>= 6.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (7.1.3)
+      activesupport (= 7.1.3)
+    activerecord (7.1.3)
+      activemodel (= 7.1.3)
+      activesupport (= 7.1.3)
+      timeout (>= 0.4.0)
+    activesupport (7.1.3)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    base64 (0.2.0)
+    bigdecimal (3.1.6)
+    concurrent-ruby (1.2.3)
+    connection_pool (2.4.1)
+    drb (2.2.0)
+      ruby2_keywords
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
+    json (2.7.1)
+    language_server-protocol (3.17.0.3)
+    lint_roller (1.1.0)
+    minitest (5.22.1)
+    minitest-hooks (1.5.1)
+      minitest (> 5.3)
+    mocha (2.1.0)
+      ruby2_keywords (>= 0.0.5)
+    mutex_m (0.2.0)
+    mysql2 (0.5.6)
+    parallel (1.24.0)
+    parser (3.3.0.5)
+      ast (~> 2.4.1)
+      racc
+    pg (1.5.5)
+    racc (1.7.3)
+    rainbow (3.1.1)
+    rake (13.1.0)
+    regexp_parser (2.9.0)
+    rexml (3.2.6)
+    rubocop (1.59.0)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.4)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.30.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.30.0)
+      parser (>= 3.2.1.0)
+    rubocop-performance (1.20.2)
+      rubocop (>= 1.48.1, < 2.0)
+      rubocop-ast (>= 1.30.0, < 2.0)
+    ruby-progressbar (1.13.0)
+    ruby2_keywords (0.0.5)
+    sqlite3 (1.7.2-arm64-darwin)
+    sqlite3 (1.7.2-x86_64-linux)
+    standard (1.33.0)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.59.0)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.3)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.3.1)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.20.2)
+    timeout (0.4.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.5.0)
+
+PLATFORMS
+  arm64-darwin-21
+  x86_64-linux
+
+DEPENDENCIES
+  minitest (~> 5.0)
+  minitest-hooks (~> 1.5.1)
+  mocha (~> 2.1.0)
+  mysql2 (~> 0.5.6)
+  pg (~> 1.5.5)
+  positioning!
+  rake (~> 13.0)
+  sqlite3 (~> 1.7.2)
+  standard (~> 1.3)
+
+BUNDLED WITH
+   2.3.8

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Brendon Muir
+
+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,206 @@
+# Positioning
+
+The aim of this gem is to allow you to easily position Active Record model instances within a scope of your choosing. In an ideal world this gem will give your model instances sequential integer positions beginning with `1`. Attempts are made to make all changes within a transaction so that position integers remain consistent. To this end, directly assigning a position is discouraged, instead you can move items by declaring an item's prior or subsequent item in the list and your item will be moved to be relative to that item.
+
+Positioning supports multiple lists per model with global, simple, and complex scopes.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'positioning'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install positioning
+
+## Usage
+
+In the simplest case our database column should be named `position` and not allow `NULL` as a value:
+
+`add_column :items, :position, :integer, null: false`
+
+You should also add an index to ensure that the `position` column value is unique within its scope:
+
+`add_index :items, [:list_id, :position], unique: true`
+
+The above assumes that your items are scoped to a parent table called `lists`.
+
+The Positioning gem uses `0` and negative integers to rearrange the lists it manages so don't add database validations to restrict the usage of these. You are also restricted from using `0` and negative integers as position values. If you try, the position value will become `1`. If you try to set an explicit position value that is greater than the next available list position, it will be rounded down to that value.
+
+### Declaring Positioning
+
+To declare that your model should keep track of the position of its records you can use the `positioned` method. Here are some examples:
+
+```ruby
+# The scope is global (all records will belong to the same list) and the databse column
+# is 'positioned'
+positioned
+
+# The scope is on the belongs_to relationship 'list' and the databse column is 'positioned'
+# We check if the scope is a belongs_to relationship and use its declared foreign_key as
+# the scope value. In this case it would be 'list_id' since we haven't overridden the
+# default foreign key.
+belongs_to :list
+positioned on: :list
+
+# If you want to change the database column used to record positions you can do so via the
+# ':column' parameter. This is most useful when you are keeping track of more than one
+# list on a model.
+belongs_to :list
+belongs_to :category
+positioned on: :list
+positioned on: :category, column: :category_position
+
+# A scope need not be a belongs_to relationship; it can be any column in the database table.
+positioned on: :type
+
+# Finally, you can have more complex scopes defined as an array of relationships and/or
+# columns.
+belongs_to :list
+belongs_to :category
+positioned on: [:list, :category, :enabled]
+```
+
+### Manipulating Positioning
+
+The tools for manipulating the position of records in your list have been kept intentionally terse. Priority has also been given to minimal pollution of the model namespace. Only two class methods are defined on all models (`positioning_columns` and `positioned`), and two instance methods are defined on models that call `positioned`:
+
+#### Accessing Relative List Items
+
+The two instance methods that we add are for finding the prior and subsequent items relative to the current item in the list. These methods are named after the database column used to track positioning. By default the methods are named `prior_position` and `subsequent_position`. In the example above where we used the column `category_position` then the methods would be named `prior_category_position` and `subsequent_category_position`.
+
+#### Assigning Positions
+
+If you don't provide a position when creating a record, your record will be added to the end of the list.
+
+To assign a specific position when creating or updating a record you can simply declare a specific value for the database column tracking the position of records (by default this is `position`). The valid options for this column are:
+
+* A specific integer value. Values are automatically clamped to between `1` and the next available position at the end of the list (inclusive). You should use explicit position values as a last resort, instead you can use:
+* `:first` places the record at the start of the list.
+* `:last` places the record at the end of the list.
+* `nil` also places the record at the end of the list.
+* `before:` and `after:` allow you to define the position relative to other records in the list. You can define the relative record by its primary key (usually `id`) or by providing the record itself. You can also provide `nil` in which case the item will be placed at the start or end of the list (see below).
+
+Position parameters can be strings or symbols, so you can provide them from the browser.
+
+Here are some examples:
+
+##### Creating
+
+```ruby
+# Added to the third position, other records are moved out of the way
+list.items.create name: 'Item', position: 3
+
+# Added to the end of the list
+list.items.create name: 'Item'
+list.items.create name: 'Item', position: :last
+list.items.create name: 'Item', position: nil
+list.items.create name: 'Item', position: {before: nil}
+
+# Added to the start of the list
+list.items.create name: 'Item', position: :first
+list.items.create name: 'Item', position: {after: nil}
+
+# Added before other_item
+list.items.create name: 'Item', position: {before: other_item}
+# or
+other_item.id # => 22
+list.items.create name: 'Item', position: {before: 22}
+
+# Added after other_item
+list.items.create name: 'Item', position: {after: other_item}
+# or
+other_item.id # => 11
+list.items.create name: 'Item', position: {after: 11}
+```
+
+##### Updating
+
+```ruby
+# Moved to the third position, other records are moved out of the way
+item.update position: 3
+
+# Moved to the end of the list
+item.update position: :last
+item.update position: nil
+item.update position: {before: nil}
+
+# Moved to the start of the list
+item.update position: :first
+item.update position: {after: nil}
+
+# Moved to before other_item
+item.update position: {before: other_item}
+# or
+other_item.id # => 22
+item.update position: {before: 22}
+
+# Moved to after other_item
+item.update position: {after: other_item}
+# or
+other_item.id # => 11
+item.update position: {after: 11}
+```
+
+#### Destroying
+
+When a record is destroyed, the positions of relative items in the scope will be shuffled to close the gap left by the destroyed record. If we detect that records are being destroyed via a scope dependency (e.g. `has_many :items, dependent: :destroy`) then we skip closing the gaps because all records in the scope will eventually be destroyed anyway.
+
+#### Scopes
+Positioning handles things for you when you change the scope of a record. If you move a record from one scope to another, the gap in the position column will be healed in the scope the record is leaving, and by default (unless you specify an explicit position) the record will be added to the end of the list in the new scope.
+
+Here are some examples of scope management:
+
+```ruby
+# Moved to being the third item in other_list
+item.update list: other_list, position: 3
+
+# Moved to the end of other_list
+item.update list: other_list
+item.update list: other_list, position: :last
+item.update list: other_list, position: nil
+item.update list: other_list, position: {before: nil}
+
+# Moved to the start of other_list
+item.update list: other_list, position: :first
+item.update list: other_list, position: {after: nil}
+
+# Moved to before other_item in other_list
+item.update list: other_list, position: {before: other_item}
+# or
+other_item.id # => 22
+item.update list: other_list, position: {before: 22}
+
+# Moved to after other_item in other_list
+item.update list: other_list, position: {after: other_item}
+# or
+other_item.id # => 11
+item.update list: other_list, position: {after: 11}
+```
+
+It's important to note that in the examples above, `other_item` must already belong to the `other_list` scope.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+This gem is tested against SQLite, PostgreSQL and MySQL. The default database for testing is MySQL. You can target other databases by prepending the environment variable `DB=sqlite` or `DB=postgresql` before `rake test`. For example: `DB=sqlite rake test`.
+
+The PostgreSQL and MySQL environments are configured under `test/support/database.yml`. You can edit this file, or preferrably adjust your environment to support passwordless socket based connections to these two database engines. You'll also need to manually create a database named `positioning_test` in each.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/brendon/positioning.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+require "standard/rake"
+
+task default: %i[test standard]

data/lib/positioning/mechanisms.rb

@@ -0,0 +1,177 @@
+module Positioning
+  class Mechanisms
+    def initialize(positioned, column)
+      @positioned = positioned
+      @column = column.to_sym
+    end
+
+    def prior
+      positioning_scope.where("#{@column}": position - 1).first
+    end
+
+    def subsequent
+      positioning_scope.where("#{@column}": position + 1).first
+    end
+
+    def create_position
+      solidify_position
+
+      expand(positioning_scope, position..)
+    end
+
+    def update_position
+      # If we're changing scope but not explicitly setting the position then we set the position
+      # to nil so that the item gets placed at the end of the list.
+      self.position = nil if positioning_scope_changed? && !position_changed?
+
+      solidify_position
+
+      # The update strategy is to temporarily set our position to 0, then shift everything out of the way of
+      # our new desired position before finalising it.
+      if positioning_scope_changed? || position_changed?
+        record_scope = base_class.where("#{primary_key_column}": primary_key)
+
+        position_was = record_scope.pick(@column)
+        record_scope.update_all "#{@column}": 0
+
+        if positioning_scope_changed?
+          positioning_scope_was = base_class.where record_scope.first.slice(*positioning_columns)
+
+          contract(positioning_scope_was, position_was..)
+          expand(positioning_scope, position..)
+
+          # If the position integer was set to the same as its prior value but the scope has changed then
+          # we need to tell Rails that it has changed so that it gets updated from the temporary 0 value.
+          position_will_change!
+        elsif position_was > position
+          expand(positioning_scope, position..position_was)
+        else
+          contract(positioning_scope, position_was..position)
+        end
+      end
+    end
+
+    def destroy_position
+      contract(positioning_scope, (position + 1)..) unless destroyed_via_positioning_scope?
+    end
+
+    private
+
+    def base_class
+      @positioned.class.base_class
+    end
+
+    def primary_key_column
+      base_class.primary_key
+    end
+
+    def primary_key
+      @positioned.send primary_key_column
+    end
+
+    def position
+      @positioned.send @column
+    end
+
+    def position=(position)
+      @positioned.send :"#{@column}=", position
+    end
+
+    def position_changed?
+      @positioned.send :"#{@column}_changed?"
+    end
+
+    def position_will_change!
+      @positioned.send :"#{@column}_will_change!"
+    end
+
+    def expand(scope, range)
+      scope.where("#{@column}": range).update_all "#{@column} = #{@column} * -1"
+      scope.where("#{@column}": ..-1).update_all "#{@column} = #{@column} * -1 + 1"
+    end
+
+    def contract(scope, range)
+      scope.where("#{@column}": range).update_all "#{@column} = #{@column} * -1"
+      scope.where("#{@column}": ..-1).update_all "#{@column} = #{@column} * -1 - 1"
+    end
+
+    def solidify_position
+      position_before_type_cast = @positioned.read_attribute_before_type_cast @column
+      position_before_type_cast.to_sym if position_before_type_cast.is_a? String
+      position_before_type_cast.symbolize_keys! if position_before_type_cast.is_a? Hash
+
+      case position_before_type_cast
+      when Integer
+        self.position = position_before_type_cast.clamp(1..last_position)
+      when :first, {after: nil}
+        self.position = 1
+      when nil, :last, {before: nil}
+        self.position = last_position
+      when Hash
+        relative_position, relative_record_or_primary_key = *position_before_type_cast.first
+
+        unless [:before, :after].include? relative_position
+          raise Error.new, "relative `#{@column}` must be either :before, :after"
+        end
+
+        relative_primary_key = if relative_record_or_primary_key.is_a? base_class
+          relative_record_or_primary_key.send(primary_key_column)
+        else
+          relative_record_or_primary_key
+        end
+
+        relative_record_scope = positioning_scope.where("#{primary_key_column}": relative_primary_key)
+
+        unless relative_record_scope.exists?
+          raise Error.new, "relative `#{@column}` record must be in the same scope"
+        end
+
+        position_was = base_class.where("#{primary_key_column}": primary_key).pick(@column)
+
+        solidified_position = relative_record_scope.pick(@column)
+        solidified_position += 1 if relative_position == :after
+        solidified_position -= 1 if in_positioning_scope? && position_was < solidified_position
+
+        self.position = solidified_position
+      end
+
+      unless position.is_a? Integer
+        raise Error.new,
+          "`#{@column}` must be an Integer, :first, :last, before: #{base_class.name}, " \
+          "after: #{base_class.name}, or nil"
+      end
+    end
+
+    def last_position
+      (positioning_scope.maximum(@column) || 0) + (in_positioning_scope? ? 0 : 1)
+    end
+
+    def positioning_columns
+      @positioned.class.positioning_columns[@column]
+    end
+
+    def positioning_scope
+      @positioned.class.where(
+        positioning_columns.to_h { |scope_component|
+          [scope_component, @positioned.send(scope_component)]
+        }
+      ).order(@column)
+    end
+
+    def in_positioning_scope?
+      @positioned.persisted? && positioning_scope.exists?(primary_key)
+    end
+
+    def positioning_scope_changed?
+      positioning_columns.any? do |scope_component|
+        @positioned.attribute_changed?(scope_component)
+      end
+    end
+
+    def destroyed_via_positioning_scope?
+      @positioned.destroyed_by_association && positioning_columns.any? do |scope_component|
+        @positioned.destroyed_by_association.foreign_key == scope_component
+      end
+    end
+  end
+end

data/lib/positioning/version.rb

@@ -0,0 +1,3 @@
+module Positioning
+  VERSION = "0.1.0"
+end

data/lib/positioning.rb

@@ -0,0 +1,43 @@
+require_relative "positioning/version"
+require_relative "positioning/mechanisms"
+
+require "active_support/concern"
+require "active_support/lazy_load_hooks"
+
+module Positioning
+  class Error < StandardError; end
+
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def positioning_columns
+      @positioning_columns ||= {}
+    end
+
+    def positioned(on: [], column: :position)
+      column = column.to_sym
+
+      if positioning_columns.key? column
+        raise Error.new "The column `#{column}` has already been used by the scope `#{positioning_columns[column]}`."
+      else
+        positioning_columns[column] = Array.wrap(on).map do |scope_component|
+          scope_component = scope_component.to_s
+          reflection = reflections[scope_component]
+
+          (reflection && reflection.belongs_to?) ? reflection.foreign_key : scope_component
+        end
+
+        define_method(:"prior_#{column}") { Mechanisms.new(self, column).prior }
+        define_method(:"subsequent_#{column}") { Mechanisms.new(self, column).subsequent }
+
+        before_create { Mechanisms.new(self, column).create_position }
+        before_update { Mechanisms.new(self, column).update_position }
+        after_destroy { Mechanisms.new(self, column).destroy_position }
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load :active_record do
+  ActiveRecord::Base.send :include, Positioning
+end

data/positioning.gemspec

@@ -0,0 +1,40 @@
+require_relative "lib/positioning/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "positioning"
+  spec.version = Positioning::VERSION
+  spec.authors = ["Brendon Muir"]
+  spec.email = ["brendon@spike.net.nz"]
+
+  spec.summary = "Simple positioning for Active Record models."
+  spec.homepage = "https://github.com/brendon/positioning"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/brendon/positioning"
+  spec.metadata["changelog_uri"] = "https://github.com/brendon/positioning/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "activesupport", ">= 6.1"
+  spec.add_dependency "activerecord", ">= 6.1"
+  spec.add_development_dependency "minitest-hooks", "~> 1.5.1"
+  spec.add_development_dependency "mocha", "~> 2.1.0"
+  spec.add_development_dependency "mysql2", "~> 0.5.6"
+  spec.add_development_dependency "pg", "~> 1.5.5"
+  spec.add_development_dependency "sqlite3", "~> 1.7.2"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/sig/positioning.rbs

@@ -0,0 +1,4 @@
+module Positioning
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: positioning
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Brendon Muir
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: minitest-hooks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.5
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+description:
+email:
+- brendon@spike.net.nz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/positioning.rb
+- lib/positioning/mechanisms.rb
+- lib/positioning/version.rb
+- positioning.gemspec
+- sig/positioning.rbs
+homepage: https://github.com/brendon/positioning
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/brendon/positioning
+  source_code_uri: https://github.com/brendon/positioning
+  changelog_uri: https://github.com/brendon/positioning/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.32
+signing_key:
+specification_version: 4
+summary: Simple positioning for Active Record models.
+test_files: []