valuable 0.6 → 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

@@ -1,40 +1,48 @@
-require 'active_support'
-require File.dirname(__FILE__) + '/boolean.rb'
-# This is the base class from which all classes that intend to use
-# Valuable should inherit.
+# Valuable is the class from which all classes (who are so inclined)
+# should inherit.
 #
-# Example:
+# ==Example:
 # 
-# class Bus < Valuable
-#   has_value :color, :default => 'yellow'
-#   has_value :number, :klass => Integer
-#   has_collection :riders
-# end
+#   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 with all the name value pairs that have values so far,
-  # either because they had a default value or because they were set in
-  # the constructor or after instanciation. Values that have not been defined
-  # and which have no default value will not appear in this collection.
+  # Returns a Hash representing all known values. Values are set three ways:
   # 
-  # Currently returns a HashWithIndifferentAccess, though that may change
-  # since it would remove the dependancy on ActiveSupport. Always use symbols
-  # to access these values.
+  #   (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}
+  #   >> bus = Bus.new(:number => 16) # color has default value 'yellow'
+  #   >> bus.attributes
+  #   => {:color => 'yellow', :number => 16}
   def attributes
-    @attributes ||= HashWithIndifferentAccess.new(deep_duplicate_of(self.class.defaults)) 
+    @attributes ||= deep_duplicate_of(self.class.defaults) 
   end
 
-  # accepts a hash that will be used to populate the predefined attributes
-  # for this class.
-  def initialize(atts = {})
-    atts.each { |name, value| __send__("#{name}=", value ) } 
+  # 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
 
-  # Creates a duplicate of all values. 
   def deep_duplicate_of(value)
     Marshal.load(Marshal.dump(value))
   end
@@ -49,92 +57,88 @@ class Valuable
     # Returns a name/value set of the values that will be used on
     # instanciation unless new values are provided.
     #
-    # class Bus < Valuable
-    #   has_value :color, :default => 'yellow'
-    # end
-    #
-    # >> Bus.defaults
-    # => {:color => 'yellow'}
-    # 
+    #   >> Bus.defaults
+    #   => {:color => 'yellow'}
     def defaults
       @defaults ||= {}
     end 
 
-    # Decorator method that determines which attributes will be available
-    # for each instance of the object being created. It accepts an
-    # attribute name (a symbol) and an options hash. Valid options are
-    # :default, :klass and (when :klass is Boolean) :negative.
+    # 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.
     #
-    # :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. 
     #
-    # :klass - light weight type casting. Use Integer, String, Boolean, or
-    # related classes. Alternately, supply a class. When that attribute is
-    # set, if the value isn't already of that class, the result will be
-    # an instance of that class, with the value passed to the constructory.
+    # 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 great example: PhoneNumber < String is useful if you
+    # 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_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
 
-    # This method returns an array of symbols, which are the only allowed
-    # options for has_value.
-    def known_options
-     [:klass, :default, :negative]
-    end
-
-    # validates option hashes passed to has_value   
-    def check_options_validity(name, options)
-      invalid_options = options.keys - known_options 
-
-      raise ArgumentError, "has_value did not know how to respond to #{invalid_options.join(', ')}. Valid (optional) arguments are: #{known_options.join(', ')}" unless invalid_options.empty?      
-    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)
-        
-      if klass == nil
+
+      case klass
+      when NilClass
+	      
         define_method "#{name}=" do |value|
           attributes[name] = value 
         end
 
-      elsif klass == Integer
+      when :integer
 
         define_method "#{name}=" do |value|
           value_as_integer = value && value.to_i
           attributes[name] = value_as_integer
         end
 
-      elsif klass == String
+      when :string
 	
 	define_method "#{name}=" do |value|
           value_as_string = value && value.to_s
           attributes[name] = value_as_string
 	end
 
-      elsif klass == Boolean
+      when :boolean
 
         define_method "#{name}=" do |value|
-          attributes[name] = !!value
+          attributes[name] = value == '0' ? false : !!value
 	end
-
+    
       else
 
         define_method "#{name}=" do |value|
@@ -160,13 +164,13 @@ class Valuable
     # In addition to the normal getter and setter, boolean attributes
     # get a method appended with a ?.
     #
-    # class Planer < Valuable
-    #   has_value :free_agent, :klass => Boolean
-    # end
+    #   class Player < Valuable
+    #     has_value :free_agent, :klass => Boolean
+    #   end
     #
-    # juan = Bus.new(:free_agent => true)
-    # >> juan.free_agent?
-    # => true
+    #   juan = Player.new(:free_agent => true)
+    #   >> juan.free_agent?
+    #   => true
     def create_question_for(name)
       define_method "#{name}?" do
         attributes[name]
@@ -175,13 +179,13 @@ class Valuable
 
     # In some situations, the opposite of a value may be just as interesting.
     #
-    # class Coder < Valuable
-    #   has_value :agilist, :klass => Boolean, :negative => :waterfaller
-    # end
+    #   class Coder < Valuable
+    #     has_value :agilist, :klass => Boolean, :negative => :waterfaller
+    #   end
     #
-    # monkey = Coder.new(:agilist => false)
-    # >> monkey.waterfaller?
-    # => true
+    #   monkey = Coder.new(:agilist => false)
+    #   >> monkey.waterfaller?
+    #   => true
     def create_negative_question_for(name, negative)
       define_method "#{negative}?" do
         !attributes[name]
@@ -191,18 +195,39 @@ class Valuable
     # this is a more intuitive way of marking an attribute as holding a
     # collection. 
     #
-    # class Bus < Valuable
-    #   has_collection :riders
-    # end
+    #   class Bus < Valuable
+    #     has_value :riders, :default => [] # meh...
+    #     has_collection :riders # better!
+    #   end
     #
-    # >> bus = Bus.new
-    # >> bus.riders << 'jack'
-    # >> bus.riders
-    # => ['jack']
+    #   >> 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

@@ -1,193 +1,76 @@
-require 'rubygems'
-
-require 'rake'
-require 'rake/rdoctask'
-require 'rake/testtask'
-require 'rake/packagetask'
-require 'rake/gempackagetask'
-require 'rake/contrib/rubyforgepublisher'
-
-task :default => [:test]
-
-PKG_NAME           = 'valuable'
-PKG_VERSION        = '0.6'
-PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_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'
-task :clean do
-  temp_filenames = File.join('**', '*.*~')
-  temp_files = Dir.glob(temp_filenames)
-  if temp_files.empty? 
-      puts 'nothing to delete' 
-  else
-      puts "deleting #{temp_files.size} 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.txt')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-spec = Gem::Specification.new do |s| 
-  s.name = PKG_NAME
-  s.version = PKG_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. Its aim is to provide Rails-like goodness where ActiveRecord isn't an option. 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}/**/*"].to_a + %w( README.txt rakefile.rb )
-  s.add_dependency 'activesupport'
-  s.require_path = 'lib'
-  s.test_files = FileList["{test}/**/*test.rb"].to_a
-  s.has_rdoc = false
-
-  s.rubyforge_project = RUBY_FORGE_PROJECT
-  s.author = 'Johnathon Wright'
-  s.email = 'jw@mustmodify.com'
-  s.homepage = 'http://valuable.mustmodify.com'
-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]
-
-desc "Publish the release files to RubyForge."
-task :rubyforge_upload => :package do
-  files = %w(gem tgz).map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" }
-
-  if RUBY_FORGE_PROJECT then
-    require 'net/http'
-    require 'open-uri'
-
-    project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/"
-    project_data = open(project_uri) { |data| data.read }
-    group_id = project_data[/[?&]group_id=(\d+)/, 1]
-    raise "Couldn't get group id" unless group_id
-
-    # This echos password to shell which is a bit sucky
-    if ENV["RUBY_FORGE_PASSWORD"]
-      password = ENV["RUBY_FORGE_PASSWORD"]
-    else
-      print "#{RUBY_FORGE_USER}@rubyforge.org's password: "
-      password = STDIN.gets.chomp
-    end
-
-    login_response = Net::HTTP.start("rubyforge.org", 80) do |http|
-      data = [
-        "login=1",
-        "form_loginname=#{RUBY_FORGE_USER}",
-        "form_pw=#{password}"
-      ].join("&")
-      http.post("/account/login.php", data)
-    end
-
-    cookie = login_response["set-cookie"]
-    raise "Login failed" unless cookie
-    headers = { "Cookie" => cookie }
-
-    release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}"
-    release_data = open(release_uri, headers) { |data| data.read }
-    package_id = release_data[/[?&]package_id=(\d+)/, 1]
-    raise "Couldn't get package id" unless package_id
-
-    first_file = true
-    release_id = ""
-
-    files.each do |filename|
-      basename  = File.basename(filename)
-      file_ext  = File.extname(filename)
-      file_data = File.open(filename, "rb") { |file| file.read }
-
-      puts "Releasing #{basename}..."
-
-      release_response = Net::HTTP.start("rubyforge.org", 80) do |http|
-        release_date = Time.now.strftime("%Y-%m-%d %H:%M")
-        type_map = {
-          ".zip"    => "3000",
-          ".tgz"    => "3110",
-          ".gz"     => "3110",
-          ".gem"    => "1400"
-        }; type_map.default = "9999"
-        type = type_map[file_ext]
-        boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor"
-
-        query_hash = if first_file then
-          {
-            "group_id" => group_id,
-            "package_id" => package_id,
-            "release_name" => PKG_FILE_NAME,
-            "release_date" => release_date,
-            "type_id" => type,
-            "processor_id" => "8000", # Any
-            "release_notes" => "",
-            "release_changes" => "",
-            "preformatted" => "1",
-            "submit" => "1"
-          }
-        else
-          {
-            "group_id" => group_id,
-            "release_id" => release_id,
-            "package_id" => package_id,
-            "step2" => "1",
-            "type_id" => type,
-            "processor_id" => "8000", # Any
-            "submit" => "Add This File"
-          }
-        end
-
-        query = "?" + query_hash.map do |(name, value)|
-          [name, URI.encode(value)].join("=")
-        end.join("&")
-
-        data = [
-          "--" + boundary,
-          "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"",
-          "Content-Type: application/octet-stream",
-          "Content-Transfer-Encoding: binary",
-          "", file_data, ""
-          ].join("\x0D\x0A")
-
-        release_headers = headers.merge(
-          "Content-Type" => "multipart/form-data; boundary=#{boundary}"
-        )
-
-        target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php"
-        http.post(target + query, data, release_headers)
-      end
-
-      if first_file then
-        release_id = release_response.body[/release_id=(\d+)/, 1]
-        raise("Couldn't get release id") unless release_id
-      end
-
-      first_file = false
-    end
-  end
-end
-
+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

@@ -1,23 +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
+$: << 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

@@ -4,9 +4,6 @@ require 'test/unit'
 require 'valuable.rb'
 require 'mocha'
 
-class Signature < String
-end
-
 class Cubical < String
   def initialize(number)
     super "Lives in Cubical #{number}"
@@ -20,17 +17,16 @@ class DevCertifications < Valuable
 end
 
 class Developer < Valuable
-  has_value :experience, :klass => Integer
+  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 :signature, :klass => Signature
-  has_value :snacks_per_day, :klass => Integer, :default => 7
+  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, :default => DevCertifications.new
+  has_value :certifications, :klass => DevCertifications, :default => DevCertifications.new
   has_value :quote
-  has_value :employed, :klass => Boolean, :negative => 'unemployed'
+  has_value :employed, :klass => :boolean, :negative => 'unemployed'
 
   has_collection :favorite_gems  
 
@@ -71,8 +67,8 @@ class BaseTest < Test::Unit::TestCase
   end
 
   def test_that_attributes_can_be_klassified
-    dev = Developer.new(:signature => 'brah brah')
-    assert_equal Signature, dev.signature.class
+    dev = Developer.new(:cubical => 12)
+    assert_equal Cubical, dev.cubical.class
   end
 
   def test_that_defaults_appear_in_attributes_hash
@@ -84,7 +80,7 @@ class BaseTest < Test::Unit::TestCase
   end
 
   def test_that_randomly_classed_attributes_persist_nils
-    assert_equal nil, Developer.new.signature
+    assert_equal nil, Developer.new.cubical
   end
 
   def test_that_randomly_classed_attributes_respect_defaults
@@ -103,7 +99,7 @@ class BaseTest < Test::Unit::TestCase
   end
   
   def test_that_attributes_are_available_as_class_method
-    assert Developer.attributes.include?(:signature)
+    assert Developer.attributes.include?(:cubical)
   end
 
   def test_that_a_model_can_have_a_collection
@@ -143,9 +139,9 @@ class BaseTest < Test::Unit::TestCase
   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 = Developer.new(:signature => why_hammer)
+    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
@@ -168,6 +164,10 @@ class BaseTest < Test::Unit::TestCase
     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
@@ -179,4 +179,16 @@ class BaseTest < Test::Unit::TestCase
   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

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: valuable
 version: !ruby/object:Gem::Version 
-  version: "0.6"
+  version: "0.8"
 platform: ruby
 authors: 
 - Johnathon Wright
@@ -9,20 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-22 00:00:00 -05:00
+date: 2009-12-16 00:00:00 -06:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: activesupport
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
-description: Valuable is a ruby base class that is essentially attr_accessor on steroids. Its aim is to provide Rails-like goodness where ActiveRecord isn't an option. It intends to use a simple and intuitive interface, allowing you to get on with the logic specific to your application.
+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: []
 
@@ -31,12 +22,11 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/boolean.rb
 - lib/valuable.rb
-- README.txt
+- README.markdown
 - rakefile.rb
 has_rdoc: true
-homepage: http://valuable.mustmodify.com
+homepage: http://www.github.com/mustmodify/valuable
 licenses: []
 
 post_install_message: 
@@ -59,10 +49,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: valuable
-rubygems_version: 1.3.3
+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

data/README.txt

@@ -1,79 +0,0 @@
-
-=Introducing Valuable
-
-Valuable is a ruby base class that is essentially attr_accessor on steroids. Its aim is to provide Rails-like goodness without the database.  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.
-
-Valuable provides DRY decoration like attr_accessor, but includes default values, light weight type casting, a constructor that accepts an attributes hash, a class-level list of attributes, an instance-level attributes hash, and more.
-
-==Example
-
-class BaseballPlayer < Valuable
-
-  has_value :at_bats, :klass => Integer
-  has_value :hits, :klass => Integer
-  has_value :league, :default => 'unknown'
-  has_value :name, :dependency => true
-  has_value :cell, :klass => PhoneNumber, :default => 'Unknown'
-  has_value :active, :klass => Boolean
-
-  has_collection :teammates
-
-  def average
-    hits/at_bats.to_f if hits && at_bats
-  end
-end
-
-
-joe = BaseballPlayer.new(:name => 'Joe', :hits => 5, :at_bats => 20, :cell => '1234567890')
-
-joe.at_bats
-
-20
-
-joe.active?
-
-nil
-
-joe.league
-
-'unknown'
-
-joe.average
-
-0.25
-
-joe.at_bats = nil
-
-joe.average
-
-nil
-
-joe.teammates
-
-[]
-
-joe.cell
-
-'(123) 456-7890'
-
-joe.cell = nil
-
-joe.cell
-
-nil
-
-==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. See "jersey" example above. 
-
-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
-
-Boolean is defined as a module in lib for uniformity.
-
-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/boolean.rb

@@ -1,2 +0,0 @@
-module Boolean
-end