Skip to content

quick ruby modeling -- basically attr_accessor with default values, light-weight casting, and a constructor


Notifications You must be signed in to change notification settings


Repository files navigation

Introducing Valuable

Valuable enables quick modeling... it's attr_accessor on steroids. Its simple interface allows you to build, change and discard models without hassles, so you can get on with the logic specific to your application.

When working with Rails, Sinatra etc., I find myself creating non-Active-Record classes to create testable classes for:

  • reports
  • events (model interactions between classes; this code does not belong in either a controller or an ORM model.)
  • view helpers ( very hard to test in Rails unless they're in a class like EmployeePresenter or DashboardPresenter )
  • incoming / outgoing API handlers (ie MapQuest::GeoCoder or LocalCache::GeoCoder )
  • search ( Search but also EmployeeSearch, co).incomplete_pto_for(year), etc.
  • factories

Here's an example of modeling an event, logic that doesn't belong in either a controller or a model:

class EmployeeHireAide < Valuable
    has_value :employee, klass: Employee
    has_value :hire_date, klass: :date
    has_value :current_user               

    def fire do |success|
        if success

    def add_note_about_hiring
      Note.create(notable: employee, author: current_user, event: 'Hire', body: "Hired employee on #{hire_date.to_s(:mdy)}")

    def create_documentation_checklist
      ChecklistTemplate.find_by_name('employee_documentation').create_checklist(reference: employee)

    def create_user_account
      ... etc ...

Then in your controller:

class EmployeeController
  def create
    aide = params[:employee], current_user: current_user, hire_date: params[:hire_date])

    if !current_user.can_create?(:employee)
      redirect_to aide.employee
      render action: :new

Valuable provides DRY decoration like attr_accessor, but includes default values and other formatting (like, "2" => 2), and a constructor that accepts an attributes hash. It provides a class-level list of attributes, an instance-level attributes hash, and more.

Tested with Rubinius, 1.8.7, 1.9.1, 1.9.2, 1.9.3

Version 0.9.x is considered stable.

Valuable was originally created to avoid the repetition of writing the constructor-accepts-a-hash method. It has evolved, but at its core are still the same concepts.


Frequent Uses

Valuable was created to help you quickly model things. Things I find myself modeling:

  • data imported from JSON, XML, etc
  • the result of an API call
  • a subset of some data in an ORM class say you have a class Person with street, city, state and zip. It might not make sense to store this in a separate table, but you can still create an Address model to hold address-related logic and state like geocode, post_office_box? and Address#==
  • as a presenter that wraps a model This way you keep view-specific methods out of views and models.
  • as a presenter that aggregates several models Generating a map might involve coordinating several different collections of data. Create a valuable class to handle that integration.
  • to model search forms - Use Valuable to model an advanced search form. Create an attribute for each drop-down, check-box, and text field, and constants to store options. Integrates easily with Rails via @search =[:search]) and form_for(@search, :url => ...)
  • to model reports like search forms, reports can be stateful when they have critiera that can be selected via form.
  • as a query builder ie, "I need to create an (Arel or SQL) query based off of form input." (see previous two points)
  • experiments / spikes
  • factories factories need well-defined input, so valuable is a great fit.


Class-Level Methods

has_value(field_name, options = {})

creates a getter and setter named field_name


  • default - provide a default value
class Task < Valuable
  has_value :status, :default => 'Active'
=> 'Active'
class Person < Valuable
  has_value :age, :klass => :integer
  has_value :phone_number, :klass => PhoneNumber

>> => '15').age.class
=> Fixnum

>> jenny = => '2018675309')

>> jenny.phone_number =='2018675309')
=> true
  • parse_with - Sometimes you want to instantiate with a method other than new... one example being Date.parse
class Person
  has_value :dob, :klass => Date, :parse_with => :parse

# this will call Date.parse('1976-07-26') => '1976-07-26')

has_collection(field_name, options = {})

like has_value, this creates a getter and setter. The default value is an array.


  • klass - apply pre-defined or custom formatters to each element of the array.
  • alias - create additional getters and setters under this name.
  • extend - extend the collection with the provided module or modules.
class Person
  has_collection :friends

=>   []


an array of attributes you have defined on a model.

class Person < Valuable
  has_value :first_name
  has_value :last_name

>> Person.attributes
=> [:first_name, :last_name]


A hash of the attributes with their default values. Attributes defined without default values do not appear in this list.

class Pastry < Valuable
  has_value :primary_ingredient, :default => :sugar
  has_value :att_with_no_default

>> Pastry.defaults
=> {:primary_ingredient => :sugar}

register_formatter(name, &block)

Allows you to provide custom code to pre-format attributes, if the included ones are not sufficient. For instance, you might wish to register an 'orientation' formatter that accepts either angles or 'N', 'S', 'E', 'W', and converts those to angles. See registering formatters for details and examples.

Note: as with other formatters, nil values will not be passed to the formatter. The attribute will simply be set to nil. See nil values. If this is an issue, let me know.


Valuable classes typically raise an error if you instantiate them with attributes that have not been predefined. This method makes Valuable ignore any unknown attributes.

Instance-Level Methods


provides a hash of the attributes and their values.

class Party < Valuable
  has_value :host
  has_value :theme
  has_value :time, :default => '6pm'

>> party = => 'Black and Whitle')

>> party.attributes
=> {:theme => 'Black and White', :time => '6pm'}

# note that the 'host' attribute was not set by default, at
# instantiation, or via the setter method, so 
# it does not appear in the attributes hash.


Accepts a hash of :attribute => :value and updates each associated attributes. Will raise an exception if any of the keys isn't already set up in the class, unless you call acts_as_permissive.

class Tomatoe
  has_value :color

>> t = => 'green')
>> t.color
=> 'green'
>> t.update_attributes(:color => 'red')
>> t.color
=> 'red'

write_attribute(att_name, value)

this method is called by all the setters and, obviously, update_attributes. Using a formatter (if specified), it updates the attributes hash.

class Chicken
  has_value :gender

>> c =

>> c.gender
=> nil

>> c.write_attribute(:gender, 'F')

>> c.gender
=> 'F'


if using bundler, add this to your Gemfile:

gem 'valuable'

and the examples below should work.

Usage & Examples

class Person < Valuable
  has_value :name
  has_value :age, :klass => :integer
  has_value :phone_number, :klass => PhoneNumber
          # see /examples/phone_number.rb

params = 
  'person' =>
    'name' => 'Mr. Freud',
    'age' => "344",
    'phone_number' => '8002195642',
    'specialization_code' => "2106"

>> p =[:person])

>> p.age
=> 344

>> p.phone_number
=> (337) 326-3121

>> p.phone_number.class
=> PhoneNumber

"Yeah, I could have just done that myself."

"Right, but now you don't have to."

Constructor Accepts an Attributes Hash

>> apple = => 'Apple')

=> 'Apple'

>> apple.vitamins
=> []

Default Values

Default values are... um... you know.

class Developer
  has_value :name
  has_value :nickname, :default => 'mort'

>> dev = => 'zk')

=> 'zk'

>> dev.nickname
=> 'mort'

If there is no default value, the result will be nil, EVEN if type casting is provided. Thus, a field typically cast as an Integer can be nil. See calculation of average example.

See also:

Note: When a default value and a klass are specified, the default value will NOT be cast to type klass -- you must do it. Example:

class Person

  # WRONG!
  has_value :dob, :klass => Date, :default => '2012-07-26'

  # Correct
  has_value :dob, :klass => Date, :default => Date.parse('2012-07-26')


Nil Values

Setting an attribute to nil always results in it being nil. Default values, pre-defined formatters, and custom formatters have no effect.

class Account
  has_value :logins, :klass => :integer, :default => 0

>> => nil).loginx
=> nil 

# note this is not the same as
>> nil.to_i
=> 0


Set additional getters and setters. Useful when outside data sources have odd field names.

# This example requires active_support because of Hash.from_xml

class Software < Valuable
  has_value :name, :alias => 'Title'

>> xml = '<software><Title>Windows XP</Title></software>'

>> xp =['software'])

=> "Windows XP"

Formatting Input

The purpose of Valuable's attribute formatting is to ensure that a model's input is "corrected" and ready for use as soon as the class is instantiated. Valuable provides several formatters by default -- :integer, :boolean, and :date are a few of them. You can optionally write your own formatters -- see Registering Formatters

class BaseballPlayer < Valuable

  has_value :at_bats, :klass => :integer
  has_value :hits, :klass => :integer

  def average
    hits/at_bats.to_f if hits && at_bats

>> joe = => '5', :at_bats => '20', :on_drugs => '0' == '1')

>> joe.at_bats
=> 20

>> joe.average
=> 0.25

Pre-Defined Formatters

see also Registering Formatters

  • integer ( see nil values )
  • decimal ( casts to BigDecimal. see nil values )
  • date ( see nil values )
  • string
  • boolean ( NOTE: '0' casts to false... I'm not sure whether this is intuitive, but I would be fascinated to know when this is not the correct behavior. )
  • or any class ( formats as ) unless value.is_a?( SomeClass ) )

Extending Values

As with has_value, you can do something like:

module PirateTranslator
  def to_pirate
    "#{self} AAARRRRRGgghhhh!"

class Envelope < Valuable
  has_value :message, :extend => PirateTranslator

>> => 'contrived').message.to_pirate
=> "contrived AAARRRRRGgghhhh!"


has_collection :codez

is similar to:

has_value :codez, :default => []


  • it reads better
  • that the formatter is applied to the collection's members, not (obviously) the collection. See Formatting Collections for more details.
class MailingList < Valuable
  has_collection :emails
  has_collection :messages, :klass => BulkMessage

>> m =

>> m.emails
=> []

>> m = => [ '', '' ])

=> m.emails
>> [ '', '' ]

Formatting Collections

If a klass is specified, members of the collection will be formatted appropriately:

>> m.messages << "Houston, we have a problem"

>> m.messages.first.class
=> BulkMessage

see Advanced Collection Formatting for more complex examples.

Extending Collections

As with has_value, you can do something like:

module PirateTranslator
  def to_pirate
    "#{self} AAARRRRRGgghhhh!"

class Envelope < Valuable
  has_value :message, :extend => PirateTranslator

>> => 'contrived').message.to_pirate
=> "contrived AAARRRRRGgghhhh!"

Registering Formatters

If the default formatters don't suit your needs, Valuable allows you to write your own formatting code via register_formatter. You can even override the predefined formatters simply by registering a formatter with the same name.

# In honor of NASA's Curiosity rover, let's say you were modeling
# a rover. Here's the valuable class:

class Rover < Valuable
  has_value :orientation

Sometimes orientation comes in as 'N', 'E', 'S' or 'W', sometimes it comes in as an orientation in degrees as a string ("92"), and sometimes it comes in as an integer. Let's create a formatter that makes sure everything is formatted in degrees. Notice that we're registering this formatter on Valuable, not on Rover. It will be available to every Valuable model.

Valuable.register_formatter(:orientation) do |value|
  case value
  when Numeric
  when /^\d{1,3}$/
  when 'N', 'North'
  when 'E', 'East'
  when 'S', 'South'
  when 'W', 'West'

and then we update rover to use the new formatter:

class Rover < Valuable
  has_value :orientation, :klass => :orientation

>> => 90).orientation
=> 90

>> => '282').orientation
>> 282

>> => 'S').orientation
=> 180

More about Attributes

Access the attributes via the attributes hash. Only default and specified attributes will have entries here.

class Person < Valuable
  has_value :name
  has_value :is_developer, :default => false
  has_value :ssn

>> elvis = => 'The King')

>> elvis.attributes
=> {:name=>"The King", :is_developer=>false}

>> elvis.attributes[:name]
=> "The King"

>> elvis.ssn
=> nil

>> elvis.attributes.has_key?(:ssn)
=> false

>> elvis.ssn = '409-52-2002'  # allegedly

>> elvis.attributes[:ssn]
=> "409-52-2002"

You can write directly to the attributes hash. As far as I know, Valuable will not care. However, formatters will not be applied.

Get a list of all the defined attributes from the class:

>> Person.attributes
=> [:name, :is_developer, :ssn]

Advanced Input Parsing

When you specify a klass, Valuable will pass any input (that isn't already that klass) to the constructor. If you want to use a class-level method other than the constructor, pass the method name to parse_with. Perhaps it should have been called construct_with. :)

Default behavior:

class Customer
  has_value :payment_method, :klass => PaymentMethod

# this will call'1232123') => '1232123')

using parse_with:

require 'date'

class Person < Valuable
  has_value :date_of_birth, :alias => :dob, :klass => Date, :parse_with => :parse

  def age_in_days - dob

>> sammy = => '2012-02-17')
>> sammy.age_in_days
=> Rational(8, 1)

example using a lookup method:

class Person < ActiveRecord::Base
  def find_by_full_name( full_name )
    #some finder code

class Photograph < Valuable
  has_value :photographer, :klass => Person

use it to load associated data from an exising set...

class Planet < Valuable
  has_value :name
  has_value :spaceport

  def Planet.list
    @list ||= []

  def Planet.find_by_name( needle )
    list.find{|i| == needle }

class Spaceship < Valuable
  has_value :name
  has_value :home, :klass => Planet, :parse_with => :find_by_name

Planet.list << => 'Earth', :spaceport => 'KSC')
Planet.list << => 'Mars', :spaceport => 'Olympus Mons')

>> vger = :name => "V'ger", :home => 'Earth')
>> vger.home.spaceport
=> 'KSC'

You can also provide a lambda. This is similar to specifying a custom formatter, except that it only applies to this attribute and can not be re-used.

require 'active_support'

class Movie < Valuable
  has_value :title, :parse_with => lambda{|x| x.titleize}

>> best_movie_ever = => 'the usual suspects')

>> best_movie_ever.title
=> "The Usual Suspects"

Advanced Defaults

The :default option will accept a lambda and call it on instantiation.

class Borg < Valuable
  cattr_accessor :count
  has_value :position, :default => lambda { Borg.count += 1 }

  def designation
    "#{self.position} of #{Borg.count}"

>> Borg.count = 6
>> seven =
>> Borg.count = 9
>> seven.designation
=> '7 of 9'

Caution -- if you overwrite the constructor, you should call initialize_attributes. Otherwise, your default values won't be set up until the first time the attributes hash is called -- in theory, this could be well after initialization, and could cause unknowable gremlins. Trivial example:

class Person
  has_value :created_at, :default => lambda { }

  def initialize(atts)

>> p = 
>> # wait 10 minutes
>> p.created_at ==  # attributes initialized on first use
=> true

Advanced Collection Formatting

see Collections and Formatting Collections for basic examples. A more complex example involves nested Valuable models:

class Team < Valuable
  has_value :name
  has_value :long_name

  has_collection :players, :klass => Player

class Player < Valuable
  has_value :first_name
  has_value :last_name
  has_value :salary

t = => 'Toronto', :long_name => 'The Toronto Blue Jays', 
          'players' => [
              {'first_name' => 'Chad', 'last_name' => 'Beck', :salary => 'n/a'},
              {'first_name' => 'Shawn', 'last_name' => 'Camp', :salary => '2250000'},
              {'first_name' => 'Brett', 'last_name' => 'Cecil', :salary => '443100'},
     => 'Travis', :last_name => 'Snider', :salary => '435800')

>> t.players.first
=> #<Player:0x7fa51e4a1da0 @attributes={:salary=>"n/a", :first_name=>"Chad", :last_name=>"Beck"}>

>> t.players.last
=> #<Player:0x7fa51ea6a9f8 @attributes={:salary=>"435800", :first_name=>"Travis", :last_name=>"Snider"}>

parse_with parses each item in a collection...

class Roster < Valuable
  has_collection :players, :klass => Player, :parse_with => :find_by_name


quick ruby modeling -- basically attr_accessor with default values, light-weight casting, and a constructor