Valuable 0.8

data/README.markdown

@@ -0,0 +1,169 @@
+Introducing Valuable
+====================
+
+Valuable enables quick modeling... it's attr_accessor on steroids.  It intends to use a simple and intuitive interface, allowing you easily create models without hassles, so you can get on with the logic specific to your application. I find myself using it in sort of a presenter capacity, when I have to pull data from non-standard data sources, and to handle temporary data during imports.
+
+Valuable provides DRY decoration like attr_accessor, but includes default values, light weight type casting and a constructor that accepts an attributes hash. It provides a class-level list of attributes, an instance-level attributes hash, and more.
+
+Examples
+-------
+
+_basic syntax_
+
+      class Fruit
+        has_value :name
+        has_collection :vitamins
+      end
+
+_constructor accepts an attributes hash_
+
+      >> apple = Fruit.new(:name => 'Apple')
+
+      >> apple.name
+      => 'Apple'
+
+      >> apple.vitamins
+      => []
+
+_default values_
+
+      class Developer
+        has_value :name
+        has_value :nickname, :default => 'mort'
+      end
+
+      >> dev = Developer.new(:name => 'zk')
+
+      >> dev.name
+      => 'zk'
+
+      >> dev.nickname
+      => 'mort'
+
+_setting a value to nil overrides the default._
+
+      >> Developer.new(:name => 'KDD', :nickname => nil).nickname
+      => nil
+
+_light weight type casting_
+
+      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
+        end
+      end
+
+      >> joe = BaseballPlayer.new(:hits => '5', :at_bats => '20', :on_drugs => '0' == '1')
+
+      >> joe.at_bats
+      => 20
+
+      >> joe.average
+      => 0.25
+
+_I find myself using classes to format things... ( PhoneNumber is provided in `/examples` )_
+
+      class School < Valuable
+        has_value :name
+        has_value :phone, :klass => PhoneNumber
+      end
+
+      >> School.new(:name => 'Vanderbilt', :phone => '3332223333').phone
+      => '(333) 222-3333'
+
+_as a presenter in Rails_
+
+      class CalenderPresenter < Valuable
+        has_value :month, :klass => Integer, :default => Time.now.month
+        has_value :year, :klass => Integer, :default => Time.now.year
+
+        def start_date
+          Date.civil( year, month, 1)
+        end
+
+        def end_date
+          Date.civil( year, month, -1) #strange I know
+        end
+
+        def events
+          Event.find(:all, :conditions => event_conditions)
+        end
+        
+        def event_conditions
+          ['starts_at between ? and ?', start_date, end_date]
+        end
+      end
+
+_this class might appear in a controller like this:_
+
+      class CalendarController < ApplicationController
+        def show
+          @presenter = CalendarPresenter.new(params[:calendar])
+        end
+      end
+
+_but it's easier to understand like this:_
+
+      >> @presenter = CalendarPresenter.new({}) # first pageload
+
+      >> @presenter.start_date
+      => Tue, 01 Dec 2009
+
+      >> @presenter.end_date
+      => Thu, 31 Dec 2009
+
+      >> # User selects some other month and year; the next request looks like...
+      
+      >> @presenter = CalendarPresenter.new({:month => '2', :year => '2002'})
+
+      >> @presenter.start_date
+      => Fri, 01 Feb 2002
+
+      >> @presenter.end_date
+      => Thu, 28 Feb 2002
+
+      ...
+
+So, if you're reading this, you're probably thinking, "I could have done that!" Yes, it's true. I'll happily agree that it's a relatively simple tool if you'll agree that it lets you model a calendar with an intuitive syntax, prevents you from writing yet another obvious constructor, and allows you to keep your brain focused on your app.
+
+_you can 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
+      end
+
+      >> elvis = Person.new(:name => 'The King')
+
+      >> elvis.attributes
+      => {:name=>"The King", :is_developer=>false}      
+
+      >> elvis.attributes[:name]
+      => "The King"
+
+      >> elvis.ssn
+      => nil
+
+_also, you can get a list of all the defined attributes from the class_
+      
+      >> Person.attributes
+      => [:name, :is_developer, :ssn]
+
+Default Values
+--------------
+Default values are used when no value is provided to the constructor. If the value nil is provided, nil will be used instead of the default. 
+
+When a default value and a klass are specified, the default value will NOT be cast to type klass -- you must do it.
+
+If a value having a default is set to null after it is constructed, it will NOT be set to the default.
+
+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.
+
+KLASS-ification
+---------------
+`:integer`, `:string` and `:boolean` use `to_i`, `to_s` and `!!` respectively. All other klasses use `klass.new(value)` unless the value `is_a?(klass)`, in which case it is unmolested. Nils are never klassified. In the example above, hits, which is an integer, is `nil` if not set, rather than `nil.to_i = 0`.

data/lib/valuable.rb

@@ -0,0 +1,233 @@
+# Valuable is the class from which all classes (who are so inclined)
+# should inherit.
+#
+# ==Example:
+# 
+#   class Bus < Valuable
+#     
+#     has_value :number, :klass => :integer
+#     has_value :color, :default => 'yellow'
+#     has_collection :riders
+#   
+#   end
+#
+#   >> Bus.attributes
+#   => [:number, :color, :riders]
+#   >> bus = Bus.new(:number => '3', :riders => ['GOF', 'Fowler', 'Mort']
+#   >> bus.attributes
+#   => {:number => 3, :riders => ['GOF', 'Fowler', 'Mort'], :color => 'yellow'}
+class Valuable
+
+  # Returns a Hash representing all known values. Values are set three ways:
+  # 
+  #   (1) a default value
+  #   (2) they were passed to the constructor
+  #          Bus.new(:color => 'green')
+  #   (3) they were set via their namesake setter
+  #          bus.color = 'green'
+  #          
+  # Values that have not been set and have no default not appear in this
+  # collection. Their namesake attribute methods will respond with nil.
+  # Always use symbols to access these values.
+  # 
+  #   >> bus = Bus.new(:number => 16) # color has default value 'yellow'
+  #   >> bus.attributes
+  #   => {:color => 'yellow', :number => 16}
+  def attributes
+    @attributes ||= deep_duplicate_of(self.class.defaults) 
+  end
+
+  # accepts an optional hash that will be used to populate the 
+  # predefined attributes for this class.
+  def initialize(atts = nil)
+    atts.each { |name, value| __send__("#{name}=", value ) }  if atts
+  end
+
+  def deep_duplicate_of(value)
+    Marshal.load(Marshal.dump(value))
+  end
+
+  class << self
+
+    # Returns an array of the attributes available on this object.
+    def attributes
+      @attributes ||= []
+    end 
+
+    # Returns a name/value set of the values that will be used on
+    # instanciation unless new values are provided.
+    #
+    #   >> Bus.defaults
+    #   => {:color => 'yellow'}
+    def defaults
+      @defaults ||= {}
+    end 
+
+    # Decorator method that lets you specify the attributes for your
+    # model. It accepts an attribute name (a symbol) and an options 
+    # hash. Valid options are :default, :klass and (when :klass is 
+    # Boolean) :negative.
+    #
+    #   :default - for the given attribute, use this value if no other
+    #   is provided.
+    #
+    #   :klass - light weight type casting. Use :integer, :string or
+    #   :boolean. Alternately, supply a class. 
+    #
+    # When a :klassified attribute is set to some new value, if the value
+    # is not nil and is not already of that class, the value will be cast
+    # to the specified klass. In the case of :integer, it wil be done via
+    # .to_i. In the case of a random other class, it will be done via
+    # Class.new(value). If the value is nil, it will not be cast.
+    #
+    # A good example: PhoneNumber < String is useful if you
+    # want numbers to come out the other end properly formatted, when your
+    # input may come in as an integer, or string without formatting, or
+    # string with bad formatting.
+    # 
+    # IMPORTANT EXCEPTION
+    #
+    # Due to the way Rails handles checkboxes, '0' resolves to FALSE,
+    # though it would normally resolve to TRUE.
+    def has_value(name, options={})
+
+      name = name.to_sym
+      
+      attributes << name
+      
+      defaults[name] = options[:default] unless options[:default].nil?
+      
+      create_accessor_for(name)
+      create_question_for(name) if options[:klass] == :boolean
+      create_negative_question_for(name, options[:negative]) if options[:klass] == :boolean && options[:negative]
+      
+      create_setter_for(name, options[:klass], options[:default])
+
+      check_options_validity(name, options)
+    end
+
+    # Creates the method that sets the value of an attribute. This setter
+    # is called both by the constructor. The constructor handles type
+    # casting. Setting values via the attributes hash avoids the method
+    # defined here.
+    def create_setter_for(name, klass, default)
+
+      case klass
+      when NilClass
+	      
+        define_method "#{name}=" do |value|
+          attributes[name] = value 
+        end
+
+      when :integer
+
+        define_method "#{name}=" do |value|
+          value_as_integer = value && value.to_i
+          attributes[name] = value_as_integer
+        end
+
+      when :string
+	
+	define_method "#{name}=" do |value|
+          value_as_string = value && value.to_s
+          attributes[name] = value_as_string
+	end
+
+      when :boolean
+
+        define_method "#{name}=" do |value|
+          attributes[name] = value == '0' ? false : !!value
+	end
+    
+      else
+
+        define_method "#{name}=" do |value|
+          if value.nil?
+            attributes[name] = nil 
+	  elsif value.is_a? klass
+	    attributes[name] = value
+	  else
+	    attributes[name] = klass.new(value)
+	  end
+        end
+      end
+    end
+
+    # creates a simple accessor method named after the attribute whose
+    # value it will provide during the life of the instance.
+    def create_accessor_for(name)
+      define_method name do
+        attributes[name]
+      end
+    end
+
+    # In addition to the normal getter and setter, boolean attributes
+    # get a method appended with a ?.
+    #
+    #   class Player < Valuable
+    #     has_value :free_agent, :klass => Boolean
+    #   end
+    #
+    #   juan = Player.new(:free_agent => true)
+    #   >> juan.free_agent?
+    #   => true
+    def create_question_for(name)
+      define_method "#{name}?" do
+        attributes[name]
+      end
+    end
+
+    # In some situations, the opposite of a value may be just as interesting.
+    #
+    #   class Coder < Valuable
+    #     has_value :agilist, :klass => Boolean, :negative => :waterfaller
+    #   end
+    #
+    #   monkey = Coder.new(:agilist => false)
+    #   >> monkey.waterfaller?
+    #   => true
+    def create_negative_question_for(name, negative)
+      define_method "#{negative}?" do
+        !attributes[name]
+      end
+    end
+
+    # this is a more intuitive way of marking an attribute as holding a
+    # collection. 
+    #
+    #   class Bus < Valuable
+    #     has_value :riders, :default => [] # meh...
+    #     has_collection :riders # better!
+    #   end
+    #
+    #   >> bus = Bus.new
+    #   >> bus.riders << 'jack'
+    #   >> bus.riders
+    #   => ['jack']
+    def has_collection(name)
+      has_value(name, :default => [] )
+    end 
+
+    private
+
+    def inherited(child)
+      attributes.each {|att| child.attributes << att }
+      defaults.each {|(name, value)| child.defaults[name] = value }
+    end
+    
+    def known_options
+     [:klass, :default, :negative]
+    end
+
+    # this helper raises an exception if the options passed to has_value
+    # are wrong. Mostly written because I occasionally used :class instead
+    # of :klass and, being a moron, wasted time trying to find the issue. 
+    def check_options_validity(name, options)
+      invalid_options = options.keys - known_options 
+
+      raise ArgumentError, "has_value did not know how to respond to option(s) #{invalid_options.join(', ')}. Valid (optional) arguments are: #{known_options.join(', ')}" unless invalid_options.empty?      
+    end
+
+  end
+
+end

data/rakefile.rb

@@ -0,0 +1,76 @@
+require 'rubygems'
+require 'config.rb'
+
+require 'rake'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+
+task :default => [:test]
+
+PKG_FILE_NAME      = "#{CONFIG[:name]}-#{CONFIG[:version]}"
+RUBY_FORGE_PROJECT = 'valuable'
+RUBY_FORGE_USER    = 'mustmodify'
+
+desc "Run unit tests"
+Rake::TestTask.new("test") { |t|
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+  t.warning = true
+}
+
+desc 'clean temporary files, rdoc, and gem package'
+task :clean => [:clobber_package, :clobber_rdoc] do
+  temp_filenames = File.join('**', '*.*~')
+  temp_files = Dir.glob(temp_filenames)
+  if temp_files.empty? 
+      puts 'no temp files to delete' 
+  else
+      puts "deleting #{temp_files.size} temp files"
+  end
+  
+  File.delete(*temp_files) 
+end
+
+desc 'Generate documentation for the Valuable plugin'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.title   = 'Valuable - light weight modeling'
+  rdoc.options << '--line-numbers'
+  rdoc.options << '--inline-source'
+  rdoc.rdoc_files.include('README.markdown')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+spec = Gem::Specification.new do |s| 
+  s.name = CONFIG[:name]
+  s.version = CONFIG[:version]
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'attr_accessor on steroids with defaults, constructor, and light casting.'
+  s.description = "Valuable is a ruby base class that is essentially attr_accessor on steroids. It intends to use a simple and intuitive interface, allowing you to get on with the logic specific to your application."
+
+  s.files = FileList["{lib, test, examples}/**/*"].to_a + %w( README.markdown rakefile.rb )
+  s.require_path = 'lib'
+  s.test_files = FileList["{test}/**/*test.rb"].to_a
+  s.has_rdoc = true
+
+  s.rubyforge_project = RUBY_FORGE_PROJECT
+  s.author = 'Johnathon Wright'
+  s.email = 'jw@mustmodify.com'
+  s.homepage = 'http://www.github.com/mustmodify/valuable'
+end
+ 
+Rake::GemPackageTask.new(spec) do |pkg| 
+  #pkg.need_zip = true
+  #pkg.need_tar = true 
+end 
+
+desc "Publish the API documentation"
+task :pdoc => [:rdoc] do
+  Rake::RubyForgePublisher.new(RUBY_FORGE_PROJECT, RUBY_FORGE_USER).upload
+end
+
+desc 'Publish the gem and API docs'
+task :publish => [:pdoc, :rubyforge_upload]
+

data/test/bad_attributes_test.rb

@@ -0,0 +1,23 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'valuable.rb'
+require 'mocha'
+
+class Infrastructure < Valuable
+end
+
+class BadAttributesTest < Test::Unit::TestCase
+
+  def test_that_has_value_grumbles_when_it_gets_bad_attributes
+    assert_raises ArgumentError do
+      Infrastructure.has_value :fu, :invalid => 'shut your mouth'
+    end
+  end
+
+  def test_that_valid_arguments_cause_no_grumbling
+    assert_nothing_raised do
+      Infrastructure.has_value :bar, :klass => Integer
+    end
+  end
+end

data/test/deprecated_test.rb

@@ -0,0 +1,80 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'valuable.rb'
+require 'mocha'
+
+class Signature < String
+end
+
+class Cube < String
+  def initialize(number)
+    super "Lives in Cube #{number}"
+  end
+end
+
+class DevCertifications < Valuable
+  has_value :a_plus, :default => false
+  has_value :mcts, :default => false
+  has_value :hash_rocket, :default => false
+end
+
+class Dev < Valuable
+  has_value :has_exposure_to_sunlight, :default => false
+  has_value :mindset
+  has_value :name, :default => 'DHH Jr.', :klass => String
+  has_value :signature, :klass => Signature
+  has_value :cubical, :klass => Cube
+  has_value :hacker, :default => true
+  has_value :certifications, :default => DevCertifications.new
+  has_value :quote
+
+  has_collection :favorite_gems  
+
+end
+
+# Previously, we used :klass => Klass instead of :klass => :klass.
+# I decided it was just plain dirty. On refactoring, I realized that
+# most it would continue to work. Other stuff, unfortunately, would
+# break horribly. (Integer.new, for instance, makes Ruby very angry.)
+# The purpose of these tests is to verify that everything _either_ 
+# breaks horribly or works, where the third option is fails silently
+# and mysteriously.
+class DeprecatedTest < Test::Unit::TestCase
+  
+  def test_that_attributes_can_be_klassified
+    dev = Dev.new(:signature => 'brah brah')
+    assert_equal Signature, dev.signature.class
+  end
+
+  def test_that_randomly_classed_attributes_persist_nils
+    assert_equal nil, Dev.new.signature
+  end
+
+  def test_that_randomly_classed_attributes_respect_defaults
+    assert_equal 'DHH Jr.', Dev.new.name
+  end
+
+  def test_that_constructor_casts_attributes
+    assert_equal 'Lives in Cube 20', Dev.new(:cubical => 20).cubical
+  end
+
+  def test_that_setter_casts_attributes
+    golden_boy = Dev.new
+    golden_boy.cubical = 20
+    
+    assert_equal 'Lives in Cube 20', golden_boy.cubical
+  end
+
+  def test_that_properly_klassed_values_are_not_rekast
+    why_hammer = Signature.new('go ask your mom')
+    Signature.expects(:new).with(why_hammer).never
+    hammer = Dev.new(:signature => why_hammer)
+  end
+
+  def test_that_default_values_can_be_set_to_nothing
+    assert_equal nil, Dev.new(:hacker => nil).hacker
+  end
+
+end
+

data/test/inheritance_test.rb

@@ -0,0 +1,28 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'valuable.rb'
+require 'mocha'
+
+class Parent < Valuable
+  has_value :name, :default => 'unknown'
+end
+
+class Child < Parent
+  has_value :age
+end
+
+class InheritanceTest < Test::Unit::TestCase
+
+  def test_that_children_inherit_their_parents_attributes
+    assert Child.attributes.include?(:name)
+  end	  
+
+  def test_that_children_have_distinctive_attributes
+    assert Child.attributes.include?(:age)
+  end
+
+  def test_that_parents_do_not_inherit_things_from_children
+    assert_equal [:name], Parent.attributes
+  end
+end

data/test/valuable_test.rb

@@ -0,0 +1,194 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'valuable.rb'
+require 'mocha'
+
+class Cubical < String
+  def initialize(number)
+    super "Lives in Cubical #{number}"
+  end
+end
+
+class DevCertifications < Valuable
+  has_value :a_plus, :default => false
+  has_value :mcts, :default => false
+  has_value :hash_rocket, :default => false
+end
+
+class Developer < Valuable
+  has_value :experience, :klass => :integer
+  has_value :has_exposure_to_sunlight, :default => false
+  has_value :mindset
+  has_value :name, :default => 'DHH Jr.', :klass => :string
+  has_value :snacks_per_day, :klass => :integer, :default => 7
+  has_value :cubical, :klass => Cubical
+  has_value :hacker, :default => true
+  has_value :certifications, :klass => DevCertifications, :default => DevCertifications.new
+  has_value :quote
+  has_value :employed, :klass => :boolean, :negative => 'unemployed'
+
+  has_collection :favorite_gems  
+
+end
+
+class BaseTest < Test::Unit::TestCase
+ 
+  def test_that_an_attributes_hash_is_available
+    assert_kind_of(Hash, Developer.new.attributes)
+  end
+
+  def test_that_static_defaults_hash_is_available  
+    assert_equal 'DHH Jr.', Developer.defaults[:name]
+  end
+  
+  def test_that_an_accessor_is_created
+    dev = Developer.new(:mindset => :agile)
+    assert_equal :agile, dev.mindset
+  end
+  
+  def test_that_setter_is_created
+    dev = Developer.new
+    dev.mindset = :enterprisey
+    assert_equal :enterprisey, dev.mindset
+  end
+  
+  def test_that_attributes_can_be_cast_as_integer
+    dev = Developer.new(:experience => 9.2)
+    assert_equal 9, dev.experience
+  end
+  
+  def test_that_integer_attributes_respect_default
+    assert_equal 7, Developer.new.snacks_per_day
+  end
+
+  def test_that_an_integer_attribute_with_no_value_results_in_nil
+    assert_equal nil, Developer.new.experience
+  end
+
+  def test_that_attributes_can_be_klassified
+    dev = Developer.new(:cubical => 12)
+    assert_equal Cubical, dev.cubical.class
+  end
+
+  def test_that_defaults_appear_in_attributes_hash
+    assert_equal false, Developer.new.attributes[:has_exposure_to_sunlight]
+  end
+  
+  def test_that_attributes_can_have_default_values
+    assert_equal false, Developer.new.has_exposure_to_sunlight
+  end
+
+  def test_that_randomly_classed_attributes_persist_nils
+    assert_equal nil, Developer.new.cubical
+  end
+
+  def test_that_randomly_classed_attributes_respect_defaults
+    assert_equal 'DHH Jr.', Developer.new.name
+  end
+
+  def test_that_constructor_casts_attributes
+    assert_equal 'Lives in Cubical 20', Developer.new(:cubical => 20).cubical
+  end
+
+  def test_that_setter_casts_attributes
+    golden_boy = Developer.new
+    golden_boy.cubical = 20
+    
+    assert_equal 'Lives in Cubical 20', golden_boy.cubical
+  end
+  
+  def test_that_attributes_are_available_as_class_method
+    assert Developer.attributes.include?(:cubical)
+  end
+
+  def test_that_a_model_can_have_a_collection
+    assert_equal [], Developer.new.favorite_gems
+  end
+
+  def test_that_values_do_not_mysteriously_jump_instances
+    panda = Developer.new
+    panda.mindset = 'geek'
+
+    hammer = Developer.new
+    
+    assert_not_equal 'geek', hammer.mindset
+  end
+  
+  def test_that_collection_values_do_not_roll_across_instances
+    jim = Developer.new
+    jim.favorite_gems << 'Ruby'
+
+    clark = Developer.new
+
+    assert_equal [], clark.favorite_gems
+  end
+
+  def test_that_attributes_are_cast
+    panda = Developer.new(:name => 'Code Panda', :experience => '8')
+    assert_kind_of Integer, panda.attributes[:experience]
+  end
+
+  def test_that_stringy_keys_are_tried_in_absence_of_symbolic_keys
+    homer = Developer.new('quote' => "D'oh!")
+    assert_equal "D'oh!", homer.quote 
+  end
+
+  def test_that_default_values_from_seperate_instances_are_not_references_to_the_default_value_for_that_field
+    assert_not_equal Developer.new.favorite_gems.object_id, Developer.new.favorite_gems.object_id
+  end
+
+  def test_that_properly_klassed_values_are_not_rekast
+    stapler = Cubical.new('in sub-basement')
+    Cubical.expects(:new).with(stapler).never
+    Developer.new(:cubical => stapler)
+  end
+
+  def test_that_values_can_be_set_to_false
+    assert_equal false, Developer.new(:hacker => false).hacker
+  end
+
+  def test_that_default_values_needing_deep_duplication_get_it
+    a = Developer.new
+    b = Developer.new
+
+    a.certifications.hash_rocket = true
+    assert_equal false, b.certifications.hash_rocket    
+  end
+
+  def test_that_default_values_can_be_set_to_nothing
+    assert_equal nil, Developer.new(:hacker => nil).hacker
+  end
+
+  def test_that_values_are_cast_to_boolean
+    assert_equal false, Developer.new(:employed => nil).employed
+  end
+
+  def test_that_string_zero_becomes_false
+    assert_equal false, Developer.new(:employed => '0').employed
+  end
+
+  def test_that_boolean_values_get_questionmarked_methods
+    assert Developer.instance_methods.include?('employed?')
+  end
+
+  def test_that_boolean_values_get_negative_methods
+    assert Developer.instance_methods.include?('unemployed?')
+  end
+
+  def test_that_negative_methods_are_negative
+    assert_equal true, Developer.new(:employed => false).unemployed?
+  end
+
+  def test_that_constructor_can_handle_an_instance_of_nothing
+    assert_nothing_raised do
+      Developer.new(nil)
+    end
+  end
+
+  def test_that_klassification_does_not_break_when_stringified
+    assert_nothing_raised do
+      Developer.new(:experience => '2')
+    end
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification 
+name: Valuable
+version: !ruby/object:Gem::Version 
+  version: "0.8"
+platform: ruby
+authors: 
+- Johnathon Wright
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-09 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: Valuable is a ruby base class that is essentially attr_accessor on steroids. It intends to use a simple and intuitive interface, allowing you to get on with the logic specific to your application.
+email: jw@mustmodify.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/valuable.rb
+- README.markdown
+- rakefile.rb
+has_rdoc: true
+homepage: http://www.github.com/mustmodify/valuable
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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: valuable
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: attr_accessor on steroids with defaults, constructor, and light casting.
+test_files: 
+- test/bad_attributes_test.rb
+- test/deprecated_test.rb
+- test/inheritance_test.rb
+- test/valuable_test.rb