Often times, we have an AR model that has a notion of position. Take, for example, employees in a company. You may want to assign a position to each employee such as CEO, VP of Engineering, Director of Marketing, Employee #1, #2, etc. Or, in the case of Mixbook, lets say you have a page in a book. The page can have a position like Front Cover, Back Cover, Page #1, etc. The more you think about, you'll realize that there other things that fall well into this paradigm.

My goal was to create a extension to AR to help with these kinds of a problem in an elegant, space efficient way. Many times, people end up creating new columns for each different type of position. For the case of employee, you might add a new column when you have a new position. It's easy to see how this can get unwieldy very fast. In my approach, I use the smallest possible footprint by modeling this paradigm using a 1-4 byte signed integer column. So if you only have a couple of positions, you could use a signed TinyInt and get all this functionality in a byte!

Here is how it works!


class Employee < ActiveRecord::Base
 
  ## Columns ##
  # id: Integer
  # corporate_position: Integer
  # company_id: Integer
 
  belongs_to :company
 
  # Optional - custom position type
  module PositionTypes
    class Designer < ActiveRecord::Acts::Positionable::Types::Special
       def name
         "Some awesome designer"
       end
    end
  end
 
  acts_as_positionable(:column => "corporate_position") do |p|
    # A normal number will refer to the "normal" employees
    p.number 
 
    p.special(-1, "CEO")
    p.special(-2, "CTO")
    p.special(-3, "CFO")
    p.special(-4, "VP Corporate Development")
    p.special(-5, "VP Marketing", :sort_index => 1000000)  # we don't like those guys, should come at end
 
    # designer comes from custom the custom position type class defined above.
    p.designer(-6, "Lead Designer") # 
 
    p.group(-100, "Executive Team", [:ceo, :cto, :cfo])
    p.pattern(-200, "Odd", "@value.modulo(2)==1")
  end
 
end
class Company < ActiveRecord::Base
 
  ## Columns ##
  # id: Integer
 
   has_many_with_position :employees
 
end
Values greater than zero are used to model a generic number, ie Employee #1, Page #1. However, the negative values are used to represent special positions, group positions, and pattern positions. Here is the functionality that we get.

QUESTION METHODS

employee = Employee.create!(:corporate_position => :ceo) # => #<Employee id: 2, corporate_position: -1, company_id: nil>
employee.ceo? # => true
employee.vp_corporate_development? # => false
employee.number?(4) # => false
employee.executive_team? # => true

All these methods are created on the model, the position, and the has many association associated with it:


company = Company.create! # => <Company id: 1>
company.employees << Employee.new(:corporate_position => :cto) # => [<Employee id: 3, corporate_position: -2, company_id: 1>]
company.employees.cto? # Does the company have any employees on it that are a cto? # => true
company.employees.first.cto? # Is the employee a cto? # => true
company.employees.first.corporate_position.cto? # Is the corporate_position of this employee that of a cto? # => true

The last two use cases are pretty much the same thing but are provided for convenience.

If you want to change position of an employee, there are a couple of ways to do this:

WRITE METHODS

employee.vp_marketing = true # => true
employee # => <Employee id: 2, corporate_position: -5, company_id: nil> 

Or you can just set the column directly:

employee.corporate_position = :ceo # => :ceo
employee # => <Employee id: 2, corporate_position: -1, company_id: nil>

FINDER METHODS

Wouldn't it be cool to also be able to use the position in your finders as well? Check this out...

Employee.find_by_corporate_position(:ceo) # => #<Employee id: 2, corporate_position: -1, company_id: nil>
Employee.find_all_by_corporate_position(:ceo) # => [#<Employee id: 2, corporate_position: -1, company_id: nil>]
Employee.first(:conditions => {:corporate_position => :ceo}) # => #<Employee id: 2, corporate_position: -1, company_id: nil>
Each position type comes with basic methods for common use cases as well:

OTHER METHODS

position = Employee.positions[:cto] # => #<ActiveRecord::Acts::Positionable::Types::Special:0x366da70 @name="CTO", @_memoized_titleize=["The CTO"], @_memoized_to_sym=[:cto], @value=-2, @sort_index=-2, @_memoized_short_name=["CTO"]>
position.to_sym # => :cto # or position.keyword
position.to_i # => -2
position.titleize # => "The CTO"
position.short_name # => "CTO"
position.value # => -2
position.name # => "CTO"

POSITION TYPES

I've created two abstract position type classes with the rest extending from there:

Primitive
  Number - basic number values. All numbers are greater then zero.
  Special - represents a single non-number type (ie "CEO" or "CTO")
Complex
  Group - create a group of other positions (ie "Executive Team").
  Pattern - represents a pattern of positions (ie "Odd")
  Function - derive a custom function to match the position (experimental)

The beauty of this system is that you can customize this AR plugin with additional functionality. In the example provided, we subclassed ActiveRecord::Acts::Positionable::Types::Special to create a new "designer" type:

Employee.new(:corporation_position => :lead_designer).name
# =>  "Some awesome designer"

This way we can overwrite any of the functionality from the core position classes as demonstrated above.

I haven't had a chance to package this into a plugin, but you can stick it into your lib folder and give it a go.