valuable 0.6

data/README.txt

@@ -0,0 +1,79 @@
+
+=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

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

data/lib/valuable.rb

@@ -0,0 +1,208 @@
+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.
+#
+# Example:
+# 
+# class Bus < Valuable
+#   has_value :color, :default => 'yellow'
+#   has_value :number, :klass => Integer
+#   has_collection :riders
+# end
+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.
+  # 
+  # Currently returns a HashWithIndifferentAccess, though that may change
+  # since it would remove the dependancy on ActiveSupport. 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 ||= HashWithIndifferentAccess.new(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 ) } 
+  end
+
+  # Creates a duplicate of all values. 
+  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.
+    #
+    # class Bus < Valuable
+    #   has_value :color, :default => 'yellow'
+    # end
+    #
+    # >> 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.
+    #
+    # :default - for the given attribute, use this value if no other is
+    # provided.
+    #
+    # :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.
+    #
+    # A great 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.
+    def has_value(name, options={})
+      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
+
+    # 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
+        define_method "#{name}=" do |value|
+          attributes[name] = value 
+        end
+
+      elsif klass == Integer
+
+        define_method "#{name}=" do |value|
+          value_as_integer = value && value.to_i
+          attributes[name] = value_as_integer
+        end
+
+      elsif klass == String
+	
+	define_method "#{name}=" do |value|
+          value_as_string = value && value.to_s
+          attributes[name] = value_as_string
+	end
+
+      elsif klass == Boolean
+
+        define_method "#{name}=" do |value|
+          attributes[name] = !!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 Planer < Valuable
+    #   has_value :free_agent, :klass => Boolean
+    # end
+    #
+    # juan = Bus.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_collection :riders
+    # end
+    #
+    # >> bus = Bus.new
+    # >> bus.riders << 'jack'
+    # >> bus.riders
+    # => ['jack']
+    def has_collection(name)
+      has_value(name, :default => [] )
+    end 
+
+  end
+
+end

data/rakefile.rb

@@ -0,0 +1,193 @@
+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
+

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/valuable_test.rb

@@ -0,0 +1,182 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'valuable.rb'
+require 'mocha'
+
+class Signature < String
+end
+
+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 :signature, :klass => Signature
+  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 :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(:signature => 'brah brah')
+    assert_equal Signature, dev.signature.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.signature
+  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?(:signature)
+  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
+    why_hammer = Signature.new('go ask your mom')
+    Signature.expects(:new).with(why_hammer).never
+    hammer = Developer.new(:signature => why_hammer)
+  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_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
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: valuable
+version: !ruby/object:Gem::Version 
+  version: "0.6"
+platform: ruby
+authors: 
+- Johnathon Wright
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-22 00:00:00 -05: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.
+email: jw@mustmodify.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/boolean.rb
+- lib/valuable.rb
+- README.txt
+- rakefile.rb
+has_rdoc: true
+homepage: http://valuable.mustmodify.com
+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.3
+signing_key: 
+specification_version: 3
+summary: attr_accessor on steroids with defaults, constructor, and light casting.
+test_files: 
+- test/bad_attributes_test.rb
+- test/valuable_test.rb