valuable 0.8.5 → 0.9.0

data/.gitignore

@@ -0,0 +1,7 @@
+*.*~
+.bundle
+.rvmrc
+.svn
+pkg
+vendor
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,10 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in sketch.gemspec
+gemspec
+
+group :test do
+  gem 'test-unit'
+  gem 'mocha'
+end
+

data/README.markdown

@@ -3,14 +3,36 @@ 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.
+Valuable provides DRY decoration like attr_accessor, but includes default values and other formatting, and a constructor that accepts an attributes hash. It provides a class-level list of attributes, an instance-level attributes hash, and more.
+
+Type Casting in Ruby? You must be crazy...
+-------------------------------------------------------------
+Yeah, I get that alot. I mean, about type casting. I'm not writing
+C# over here. In fact, I'm going to start using the euphamism 
+'Formatting' just so people will stop looking at me that way.
+
+Say you have get some data from a web service via JSON. 
+Parse the json and you get this:
+
+'person' => 
+  'name' => 'Mr. Freud',
+  'phone_number' => '8002195642',
+  'specialization_code' => 2106
+
+then parse it:
+
+class Person < Valuable
+  has_value :name, :default => 'Unknown'
+  has_value :phone_number
+
+      
 
 Examples
 -------
 
 _basic syntax_
 
-      class Fruit
+      class Fruit < Valuable
         has_value :name
         has_collection :vitamins
       end

data/Rakefile

@@ -0,0 +1,30 @@
+#!/usr/bin/env rake
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rake/testtask'
+
+desc "Run unit tests"
+Rake::TestTask.new("test") { |t|
+  t.libs << 'test'
+  t.pattern = 'test/*.rb'
+  t.verbose = true
+  t.warning = true
+}
+
+
+desc 'Generate HTML readme file'
+task :readme do
+  `markdown README.markdown > README.html`
+end
+
+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)
+
+  File.delete(*temp_files)
+end
+

data/examples/baseball.rb

@@ -0,0 +1,21 @@
+class Jersey < String
+  def initialize(object)
+    super "Jersey Number #{object})"
+  end
+end
+
+class BaseballPlayer < Valuable
+
+  has_value :at_bats, :klass => Integer
+  has_value :hits, :klass => Integer
+  has_value :league, :default => 'unknown'
+  has_value :name
+  has_value :jersey, :klass => Jersey, :default => 'Unknown'
+  has_value :active, :klass => Boolean
+  
+  has_collection :teammates
+
+  def average
+    hits/at_bats.to_f if hits && at_bats
+  end
+end

data/examples/phone_number.rb

@@ -0,0 +1,21 @@
+class PhoneNumber < String
+  def initialize(value)
+    super(value.to_s)
+  end
+
+  def valid?
+    has_ten_digits?  
+  end
+  
+  def has_ten_digits?
+    self =~ /\d{9}/
+  end
+
+  def inspect
+    self.to_s
+  end
+  
+  def to_s
+    "(#{self[0..2]}) #{self[3..5]}-#{self[6..9]}" if valid?
+  end
+end

data/lib/valuable.rb

@@ -36,7 +36,7 @@ class Valuable
   #   >> bus.attributes
   #   => {:color => 'yellow', :number => 16}
   def attributes
-    @attributes ||= deep_duplicate_of(self.class.defaults) 
+    @attributes ||= Valuable::Utils.deep_duplicate_of(self.class.defaults) 
   end
 
   # accepts an optional hash that will be used to populate the 
@@ -51,18 +51,24 @@ class Valuable
   #   has_value :size
   #   has_value :owner
   #   has_value :color, :default => 'red'
+  #
+  #   def big_feet?
+  #     size && size > 15
+  #   end
   # end
   #
   # >> shoe = Shoe.new
   # >> shoe.update_attributes(:size => 16, :owner => 'MJ')
   # >> shoe.attributes
   # => {:size => 16, :owner => 'MJ', :color => 'red'}
+  #
+  # can be method-chained
+  #
+  # >> Shoe.new.update_attributes(:size => 16).big_feet?
+  # => true
   def update_attributes(atts)
     atts.each{|name, value| __send__("#{name}=", value )}
-  end
-
-  def deep_duplicate_of(value)
-    Marshal.load(Marshal.dump(value))
+    self
   end
 
   def permissive?
@@ -78,23 +84,35 @@ class Valuable
   end
 
   def write_attribute(name, value)
-    self.attributes[name.to_sym] = value
+    attribute = Valuable::Utils.find_attribute_for( name, self.class._attributes )
+
+    if attribute
+      self.attributes[attribute] = Valuable::Utils.cast(attribute, value, self.class._attributes) 
+    else
+      raise( ArgumentError, "#{self.class.to_s} does not have an attribute or alias '#{name}'", caller) unless self.permissive?
+    end
   end
 
   class << self
 
     # Returns an array of the attributes available on this object.
     def attributes
-      @attributes ||= []
+      _attributes.keys
     end 
 
+    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 ||= {}
+      out = {}
+      _attributes.each{|n, atts| out[n] = atts[:default] unless atts[:default].nil?}
+      out
     end 
 
     # Decorator method that lets you specify the attributes for your
@@ -126,71 +144,43 @@ class Valuable
     # Due to the way Rails handles checkboxes, '0' resolves to FALSE,
     # though it would normally resolve to TRUE.
     def has_value(name, options={})
+      Valuable::Utils.check_options_validity(self.class.name, name, options)
 
       name = name.to_sym
-      
-      attributes << name
-      
-      defaults[name] = options[:default] unless options[:default].nil?
+      _attributes[name] = options 
       
       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])
+      create_setter_for(name)
 
       sudo_alias options[:alias], name if options[:alias]
       sudo_alias "#{options[:alias]}=", "#{name}=" if options[:alias]
-
-      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(attribute, klass)
+    # Creates the method that sets the value of an attribute.
+    # The setter calls write_attribute, which handles typicification.
+    # It is called by the constructor (rather than using
+    # write attribute, which would render any custom setters
+    # ineffective.)
+    #
+    # Setting values via the attributes hash avoids typification,
+    # ie:
+    # >> player.phone = "8778675309"
+    # >> player.phone
+    # => "(877) 867-5309"
+    #
+    # >> player.attributes[:phone] = "8778675309"
+    # >> player.phone
+    # => "8778675309"
+    def create_setter_for(attribute)
       setter_method = "#{attribute}="
 
-      case klass
-      when NilClass
-	      
-        define_method setter_method do |value|
-          write_attribute(attribute, value) 
-        end
-
-      when :integer
-
-        define_method setter_method do |value|
-          value_as_integer = value && value.to_i
-          write_attribute(attribute, value_as_integer)
-        end
-
-      when :string
-	
-	define_method setter_method do |value|
-          value_as_string = value && value.to_s
-          write_attribute(attribute, value_as_string)
-	end
-
-      when :boolean
-
-        define_method setter_method do |value|
-          write_attribute(attribute, value == '0' ? false : !!value )
-	end
-    
-      else
-
-        define_method setter_method do |value|
-          if value.nil?
-            write_attribute(attribute, nil)
-	  elsif value.is_a? klass
-	    write_attribute(attribute, value)
-	  else
-	    write_attribute(attribute, klass.new(value))
-	  end
-        end
+      define_method setter_method do |value|
+        write_attribute(attribute, value)
       end
+
     end
 
     def sudo_alias( alias_name, method_name )
@@ -199,11 +189,16 @@ class Valuable
       end
     end
 
-    # creates a simple accessor method named after the attribute whose
-    # value it will provide during the life of the instance.
+    # creates a simple accessor method named after the attribute
     def create_accessor_for(name)
-      define_method name do
-        attributes[name]
+      define_method name do |*args|
+        
+        if args.length == 0 
+          attributes[name]
+        else
+          send("#{name}=", *args)
+          self
+        end 
       end
     end
 
@@ -250,8 +245,28 @@ class Valuable
     #   >> bus.riders << 'jack'
     #   >> bus.riders
     #   => ['jack']
-    def has_collection(name)
-      has_value(name, :default => [] )
+    #
+    #   class Person
+    #     has_collection :phone_numbers, :klass => PhoneNumber
+    #   end
+    #
+    #   >> jenny = Person.new(:phone_numbers => ['8008675309'] )
+    #   >> jenny.phone_numbers.first.class
+    #   => PhoneNumber
+    def has_collection(name, options = {})
+      Utils.check_options_validity( self.class.name, name, options)
+      name = name.to_sym
+      options[:item_klass] = options[:klass] if options[:klass]
+      options[:klass] = :collection
+      options[:default] = []
+
+      _attributes[name] = options 
+      
+      create_accessor_for(name)
+      create_setter_for(name)
+
+      sudo_alias options[:alias], name if options[:alias]
+      sudo_alias "#{options[:alias]}=", "#{name}=" if options[:alias]
     end 
 
     # Instructs the class NOT to complain if any attributes are set
@@ -288,23 +303,9 @@ class Valuable
     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, :alias]
-    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?      
+      _attributes.each {|n, atts| child._attributes[n] = atts }
     end
-
   end
-
 end
+
+require 'valuable/utils'

data/lib/valuable/utils.rb

@@ -0,0 +1,92 @@
+module Valuable::Utils
+  class << self
+
+    def find_attribute_for( name, attributes )
+      name = name.to_sym
+
+      if attributes.keys.include?( name )
+        name
+      elsif found=attributes.find{|n, v| v[:alias].to_sym == name }
+        found[0]
+      end
+    end
+
+    def deep_duplicate_of(value)
+      Marshal.load(Marshal.dump(value))
+    end
+
+    def cast( name, value, attributes, collection_item = false )
+      klass = collection_item ? attributes[name][:item_klass] : attributes[name][:klass]
+
+      case klass
+      when NilClass
+
+        value
+
+      when :collection
+        if( value.kind_of?(Array) )
+          out = value.map do |item|
+            Valuable::Utils.cast( name, item, attributes, true )
+          end
+        end
+
+      when :date
+
+        case value.class.to_s
+        when "Date"
+          value
+        when "ActiveSupport::TimeWithZone", "Time", "DateTime"
+          value.to_date
+        when "String"
+          value && DateTime.parse(value)
+        else
+          value
+        end
+
+      when :integer
+
+        value && value.to_i
+
+      when :string
+        
+        value && value.to_s
+
+      when :boolean
+
+        value == '0' ? false : !!value
+      
+      else
+
+        if value.nil?
+          nil
+        elsif value.is_a? klass
+          value
+        else
+          klass.new(value)
+        end
+
+      end
+
+    end
+    
+    def klass_options
+      [NilClass, :date, :integer, :string, :boolean, Class]
+    end
+
+    def known_options
+     [:klass, :default, :negative, :alias]
+    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( class_name, attribute, 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?    
+
+      raise ArgumentError, "#{class_name} doesn't know how to format #{attribute} with :klass => #{options[:klass].inspect}" unless klass_options.any?{|klass| klass === options[:klass]}
+    end
+  end
+end
+

data/test/typical_test.rb

@@ -0,0 +1,46 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'valuable.rb'
+require 'date'
+require File.dirname(__FILE__) + '/../examples/phone_number'
+class Person < Valuable
+  has_value :dob, :klass => :date
+end
+
+class TypicalTest < Test::Unit::TestCase
+
+  def test_that_dates_can_be_set_directly
+    born_on = Date.civil(1976, 07, 26)
+    me = Person.new( :dob => born_on )
+    assert_equal( born_on, me.dob )
+  end
+
+  def test_that_dates_are_parsed_from_strings
+    neil_born_on = 'August 5, 1930'
+    neil = Person.new( :dob => neil_born_on )
+    assert_equal( Date.civil( 1930, 8, 5 ), neil.dob )
+  end
+
+  def test_that_a_date_might_not_be_set_yet_and_that_can_be_ok
+    dr_who = Person.new( :dob => nil )
+    assert_nil( dr_who.dob )
+  end
+
+  def test_that_collections_are_typified
+    people = Class.new(Valuable)
+    people.has_collection( :phones, :klass => PhoneNumber )
+
+    person = people.new(:phones => ['8668675309'])
+    assert_kind_of( Array, person.phones )
+    assert_kind_of( PhoneNumber, person.phones.first )
+  end
+
+  def test_that_it_discovers_an_invalid_klass
+    animal = Class.new(Valuable)
+    assert_raises ArgumentError, "Animal doesn't know how to format species with :klass => 'invalid'" do
+      animal.has_value :species, :klass => :invalid
+    end
+  end
+end
+

data/test/write_and_read_attribute_test.rb

@@ -5,6 +5,7 @@ require 'valuable.rb'
 
 class Beer < Valuable
   has_value :name
+  has_value :brewery
 end
 
 class AliasTest < Test::Unit::TestCase
@@ -20,5 +21,18 @@ class AliasTest < Test::Unit::TestCase
     beer.write_attribute('name', 'Fosters')
     assert_equal 'Fosters', beer.name
   end
+
+  def test_that_values_can_be_set_using_newfangled_way
+    beer = Beer.new
+    beer.name('Abita Amber')
+    assert_equal 'Abita Amber', beer.name
+  end
+
+  def test_newfangled_fluid_chaining
+    beer = Beer.new
+    beer.name('Amber').brewery('Abita')
+    assert_equal 'Abita', beer.brewery
+  end
+
 end
 

data/todo.txt

@@ -0,0 +1,91 @@
+Find some way to do 
+
+  has_value :something, :klass => Decimal
+
+  * must handle BigDecimal not being around
+
+
+- has_value :start_date, :default => {Date.today}
+- has_value :price, :default => 50, :extend => MoneyFormatter
+
+class SomeSearchThing < Valuable
+
+  has_value :dob
+  has_value :sign
+
+  parser_for( dob ) do |input|
+    Date.parse(input)
+  end
+
+end
+
+BEST PRACTICES DOC
+
+When creating a searcher:
+
+class UserSearcher < Valuable
+
+  has_value :age
+  has_value :query
+  has_value :expertise
+  has_value :eye_color
+
+  def conditions
+    [ eye_color_conditions, name_conditions, ... ].compact.join(' OR ')
+  end
+
+end
+
+
+- Rails 3 support
+- Add Valuable#to_yaml and Valuable.from_yaml
+- make it easy to include validatable or ActiveRecord::Validations
+- make it easy to use has_value from activerecord model.
+- add optional :always_klass ?
+- for :klass => :integer, 'abc' resolves to 0 ... fix that.
+- optionally, values should be on the class rather than the instance, as in:
+  Config < ValuableClass
+    has_value :background_color
+  end
+
+  Config.background_color
+
+- 2. Create a 'Valuable::Presenter' base class that filters out rails params, handles nested params, knows 0 is false for checkboxes, works with form_for#checkbox...
+
+class ProductsController < ApplicationController
+  
+  def reviews
+    @presenter = ReviewPresenter.new(params)
+
+    @product = @presenter.product
+    @reviews = @presenter.reviews 
+    
+  end
+  
+end
+
+which currently raises:
+undefined method `action=' for #<ReviewPresenter:0x5e7fa18>
+
+
+like this:
+  def initialize(atts = {})
+    super(atts.except('action', 'controller'))
+  end
+
+
+
+:klass => :decimal
+- When is decimal available? Only load then.
+- If calling :decimal and it hasn't loaded, error
+
+
+
+class Change < Decimal
+  extend Valuable::whatever or
+  extend Valuable
+
+  ...
+end
+
+- do a better job with method_missing 

data/valuable.gemspec

@@ -0,0 +1,23 @@
+$:.push File.expand_path("../lib", __FILE__)  
+version = File.read(File.expand_path("../valuable.version",__FILE__)).strip
+
+spec = Gem::Specification.new do |s|
+  s.name = 'valuable'
+  s.version = version 
+  s.summary = "attr_accessor on steroids with defaults, default constructor, and attribute formatting."
+  s.description = "Valuable is a ruby base class that is essentially attr_accessor on steroids. A simple and intuitive interface allows you to get on with modeling in your app."
+  s.license = 'MIT'
+
+  s.require_path = 'lib'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.has_rdoc = true
+
+  s.authors = ["Johnathon Wright"]
+  s.email = "jw@mustmodify.com"
+  s.homepage = "http://valuable.mustmodify.com/"
+end
+

data/valuable.version

@@ -0,0 +1 @@
+0.9.0

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: valuable
 version: !ruby/object:Gem::Version 
-  hash: 53
-  prerelease: false
+  hash: 59
+  prerelease: 
   segments: 
   - 0
-  - 8
-  - 5
-  version: 0.8.5
+  - 9
+  - 0
+  version: 0.9.0
 platform: ruby
 authors: 
 - Johnathon Wright
@@ -15,11 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-06 00:00:00 -05:00
+date: 2011-05-18 00:00:00 -05: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.
+description: Valuable is a ruby base class that is essentially attr_accessor on steroids. A simple and intuitive interface allows you to get on with modeling in your app.
 email: jw@mustmodify.com
 executables: []
 
@@ -28,19 +28,28 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/valuable.rb
+- .gitignore
+- Gemfile
 - README.markdown
-- rakefile.rb
-- test/bad_attributes_test.rb
+- Rakefile
+- examples/baseball.rb
+- examples/phone_number.rb
+- lib/valuable.rb
+- lib/valuable/utils.rb
 - test/alias_test.rb
-- test/write_and_read_attribute_test.rb
-- test/inheritance_test.rb
+- test/bad_attributes_test.rb
 - test/deprecated_test.rb
+- test/inheritance_test.rb
+- test/typical_test.rb
 - test/valuable_test.rb
+- test/write_and_read_attribute_test.rb
+- todo.txt
+- valuable.gemspec
+- valuable.version
 has_rdoc: true
-homepage: http://valuable.mustmodify.com
-licenses: []
-
+homepage: http://valuable.mustmodify.com/
+licenses: 
+- MIT
 post_install_message: 
 rdoc_options: []
 
@@ -66,15 +75,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: "0"
 requirements: []
 
-rubyforge_project: valuable
-rubygems_version: 1.3.7
+rubyforge_project: 
+rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
-summary: attr_accessor on steroids with defaults, constructor, and light casting.
-test_files: 
-- test/bad_attributes_test.rb
-- test/alias_test.rb
-- test/write_and_read_attribute_test.rb
-- test/inheritance_test.rb
-- test/deprecated_test.rb
-- test/valuable_test.rb
+summary: attr_accessor on steroids with defaults, default constructor, and attribute formatting.
+test_files: []
+

data/rakefile.rb

@@ -1,76 +0,0 @@
-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://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]
-