auser-poolparty 1.2.12 → 1.3.0

data/vendor/gems/shoulda/test/unit/product_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ProductTest < ActiveSupport::TestCase
+  context "An intangible product" do
+    subject { Product.new(:tangible => false) }
+
+    should_validate_presence_of :title
+    should_not_allow_values_for :size, "22"
+    should_allow_values_for :size, "22kb"
+    should_ensure_value_in_range :price, 0..99
+  end
+
+  context "A tangible product" do
+    subject { Product.new(:tangible => true) }
+
+    should_validate_presence_of :price
+    should_ensure_value_in_range :price, 1..9999
+    should_ensure_value_in_range :weight, 1..100
+    should_not_allow_values_for :size, "22", "10x15"
+    should_allow_values_for :size, "12x12x1"
+    should_ensure_length_in_range :size, 5..20
+  end
+end

data/vendor/gems/shoulda/test/unit/tag_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TagTest < ActiveSupport::TestCase
+  should_have_many :taggings, :dependent => :destroy
+  should_have_many :posts
+
+  should_ensure_length_at_least :name, 2
+
+  should_not_allow_mass_assignment_of :secret
+  should_allow_mass_assignment_of :name
+
+  should_fail do
+    should_not_allow_mass_assignment_of :name
+  end
+end

data/vendor/gems/shoulda/test/unit/tagging_test.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TaggingTest < ActiveSupport::TestCase
+  should_belong_to :post
+  should_belong_to :tag
+end

data/vendor/gems/shoulda/test/unit/user_test.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class UserTest < ActiveSupport::TestCase
+  fixtures :all
+
+  should_have_many :posts
+  should_have_many :dogs
+  should_have_many :cats
+
+  should_have_many :friendships
+  should_have_many :friends
+
+  should_have_one :address
+  should_have_one :address, :dependent => :destroy
+
+  should_have_db_indices :email, :name
+  should_have_index :age
+  should_have_db_index [:email, :name], :unique => true
+  should_have_db_index :age, :unique => false
+
+  should_fail do
+    should_have_db_index :phone
+    should_have_db_index :email, :unique => false
+    should_have_db_index :age, :unique => true
+  end
+
+  should_have_named_scope :old,       :conditions => "age > 50"
+  should_have_named_scope :eighteen,  :conditions => { :age => 18 }
+
+  should_have_named_scope 'recent(5)',            :limit => 5
+  should_have_named_scope 'recent(1)',            :limit => 1
+  should_have_named_scope 'recent_via_method(7)', :limit => 7
+
+  context "when given an instance variable" do
+    setup { @count = 2 }
+    should_have_named_scope 'recent(@count)', :limit => 2
+  end
+
+  should_not_allow_values_for :email, "blah", "b lah"
+  should_allow_values_for :email, "a@b.com", "asdf@asdf.com"
+  should_allow_values_for :age, 1, 10, 99
+  should_not_allow_values_for :age, "a", "-"
+  should_not_allow_values_for :ssn, "a", 1234567890
+  should_ensure_length_in_range :email, 1..100
+  should_ensure_value_in_range :age, 1..100, :low_message  => /greater/,
+                                             :high_message => /less/
+  should_fail do
+    should_ensure_value_in_range :age, 1..100, :low_message  => /more/,
+                                               :high_message => /less/
+  end
+  should_fail do
+    should_ensure_value_in_range :age, 1..100, :low_message  => /greater/,
+                                               :high_message => /fewer/
+  end
+  should_not_allow_mass_assignment_of :password
+  should_have_class_methods :find, :destroy
+  should_have_instance_methods :email, :age, :email=, :valid?
+  should_have_db_columns :name, :email, :age
+  should_have_db_column :id,    :type => "integer"
+  should_have_db_column :email, :type => "string", :default => nil, :precision => nil, :limit    => 255,
+                                :null => true,     :scale   => nil
+  should_validate_acceptance_of :eula
+  should_validate_uniqueness_of :email, :scoped_to => :name, :case_sensitive => false
+
+  should_ensure_length_is :ssn, 9, :message => "Social Security Number is not the right length"
+  should_validate_numericality_of :ssn
+
+  should_have_readonly_attributes :name
+
+  should_fail do
+    should_not_allow_mass_assignment_of :name, :age
+  end
+
+  should_have_one :profile, :through => :registration
+
+  should_fail do
+    should_have_one :profile, :through => :interview
+    should_have_one :address, :through => :registration
+  end
+end

data/vendor/gems/trollop/History.txt

@@ -1,16 +1,3 @@
-== 1.13 / 2009-03-16
-* Fix parsing of "--longarg=<value with spaces>".
-
-== 1.12 / 2009-01-30
-* Fix some unit test failures in the last release. Should be more careful.
-* Make default short options only be assigned *after* all user-specified
-  short options. Now there's a little less juggling to do when you just
-  want to specify a few short options.
-
-== 1.11 / 2009-01-29
-* Set <opt>_given keys in the results hash for options that were specified
-  on the commandline.
-
 == 1.10.2 / 2008-10-23
 * No longer try `stty size` for screen size detection. Just use curses, and
   screen users will have to deal with the screen clearing.

data/vendor/gems/trollop/README.txt

@@ -6,9 +6,7 @@ Main page: http://trollop.rubyforge.org
 
 Release announcements and comments: http://all-thing.net/search/label/trollop
 
-Documentation quickstart: See Trollop::options (for some reason rdoc isn't
-linking that; it's in the top right of the screen if you're browsing online)
-and then Trollop::Parser#opt. Also see the examples at http://trollop.rubyforge.org/.
+Documentation quickstart: See Trollop::options and Trollop::Parser#opt.
 
 == DESCRIPTION
 

data/vendor/gems/trollop/lib/trollop.rb

@@ -3,11 +3,9 @@
 ## Copyright:: Copyright 2007 William Morgan
 ## License::   GNU GPL version 2
 
-require 'date'
-
 module Trollop
 
-VERSION = "1.13"
+VERSION = "1.10.2"
 
 ## Thrown by Parser in the event of a commandline error. Not needed if
 ## you're using the Trollop::options entry.
@@ -46,11 +44,11 @@ class Parser
   ##
   ## A value of +io+ corresponds to a readable IO resource, including
   ## a filename, URI, or the strings 'stdin' or '-'.
-  SINGLE_ARG_TYPES = [:int, :integer, :string, :double, :float, :io, :date]
+  SINGLE_ARG_TYPES = [:int, :integer, :string, :double, :float, :io]
 
   ## The set of values that indicate a multiple-parameter option when
   ## passed as the +:type+ parameter of #opt.
-  MULTI_ARG_TYPES = [:ints, :integers, :strings, :doubles, :floats, :ios, :dates]
+  MULTI_ARG_TYPES = [:ints, :integers, :strings, :doubles, :floats, :ios]
 
   ## The complete set of legal values for the +:type+ parameter of #opt.
   TYPES = FLAG_TYPES + SINGLE_ARG_TYPES + MULTI_ARG_TYPES
@@ -130,13 +128,12 @@ class Parser
       when :double; :float
       when :doubles; :floats
       when Class
-        case opts[:type].name
+        case opts[:type].to_s # sigh... there must be a better way to do this
         when 'TrueClass', 'FalseClass'; :flag
         when 'String'; :string
         when 'Integer'; :int
         when 'Float'; :float
         when 'IO'; :io
-        when 'Date'; :date
         else
           raise ArgumentError, "unsupported argument type '#{opts[:type].class.name}'"
         end
@@ -164,7 +161,6 @@ class Parser
       when TrueClass, FalseClass; :flag
       when String; :string
       when IO; :io
-      when Date; :date
       when Array
         if opts[:default].empty?
           raise ArgumentError, "multiple argument type cannot be deduced from an empty array for '#{opts[:default][0].class.name}'"
@@ -174,7 +170,6 @@ class Parser
         when Numeric; :floats
         when String; :strings
         when IO; :ios
-        when Date; :dates
         else
           raise ArgumentError, "unsupported multiple argument type '#{opts[:default][0].class.name}'"
         end
@@ -202,12 +197,21 @@ class Parser
 
     ## fill in :short
     opts[:short] = opts[:short].to_s if opts[:short] unless opts[:short] == :none
-    opts[:short] = case opts[:short]
-      when /^-(.)$/; $1
-      when nil, :none, /^.$/; opts[:short]
-      else raise ArgumentError, "invalid short option name '#{opts[:short].inspect}'"
-    end
-
+    opts[:short] =
+      case opts[:short]
+      when nil
+        c = opts[:long].split(//).find { |c| c !~ INVALID_SHORT_ARG_REGEX && !@short.member?(c) }
+        raise ArgumentError, "can't generate a short option name for #{opts[:long].inspect}: out of unique characters" unless c
+        c
+      when /^-(.)$/
+        $1
+      when /^.$/
+        opts[:short]
+      when :none
+        nil
+      else
+        raise ArgumentError, "invalid short option name '#{opts[:short].inspect}'"
+      end
     if opts[:short]
       raise ArgumentError, "short option name #{opts[:short].inspect} is already taken; please specify a (different) :short" if @short[opts[:short]]
       raise ArgumentError, "a short option name can't be a number or a dash" if opts[:short] =~ INVALID_SHORT_ARG_REGEX
@@ -224,7 +228,7 @@ class Parser
 
     opts[:desc] ||= desc
     @long[opts[:long]] = name
-    @short[opts[:short]] = name if opts[:short] && opts[:short] != :none
+    @short[opts[:short]] = name if opts[:short]
     @specs[name] = opts
     @order << [:opt, name]
   end
@@ -274,6 +278,78 @@ class Parser
     @stop_on_unknown = true
   end
 
+  ## yield successive arg, parameter pairs
+  def each_arg args # :nodoc:
+    remains = []
+    i = 0
+
+    until i >= args.length
+      if @stop_words.member? args[i]
+        remains += args[i .. -1]
+        return remains
+      end
+      case args[i]
+      when /^--$/ # arg terminator
+        remains += args[(i + 1) .. -1]
+        return remains
+      when /^--(\S+?)=(\S+)$/ # long argument with equals
+        yield "--#{$1}", [$2]
+        i += 1
+      when /^--(\S+)$/ # long argument
+        params = collect_argument_parameters(args, i + 1)
+        unless params.empty?
+          num_params_taken = yield args[i], params
+          unless num_params_taken
+            if @stop_on_unknown
+              remains += args[i + 1 .. -1]
+              return remains
+            else
+              remains += params
+            end
+          end
+          i += 1 + num_params_taken
+        else # long argument no parameter
+          yield args[i], nil
+          i += 1
+        end
+      when /^-(\S+)$/ # one or more short arguments
+        shortargs = $1.split(//)
+        shortargs.each_with_index do |a, j|
+          if j == (shortargs.length - 1)
+            params = collect_argument_parameters(args, i + 1)
+            unless params.empty?
+              num_params_taken = yield "-#{a}", params
+              unless num_params_taken
+                if @stop_on_unknown
+                  remains += args[i + 1 .. -1]
+                  return remains
+                else
+                  remains += params
+                end
+              end
+              i += 1 + num_params_taken
+            else # argument no parameter
+              yield "-#{a}", nil
+              i += 1
+            end
+          else
+            yield "-#{a}", nil
+          end
+        end
+      else
+        if @stop_on_unknown
+          remains += args[i .. -1]
+          return remains
+        else
+          remains << args[i]
+          i += 1
+        end
+      end
+    end
+
+    remains
+  end
+
   ## Parses the commandline. Typically called by Trollop::options.
   def parse cmdline=ARGV
     vals = {}
@@ -287,19 +363,18 @@ class Parser
       vals[sym] = opts[:default]
     end
 
-    resolve_default_short_options
-
     ## resolve symbols
     given_args = {}
     @leftovers = each_arg cmdline do |arg, params|
-      sym = case arg
-      when /^-([^-])$/
-        @short[$1]
-      when /^--([^-]\S*)$/
-        @long[$1]
-      else
-        raise CommandlineError, "invalid argument syntax: '#{arg}'"
-      end
+      sym = 
+        case arg
+        when /^-([^-])$/
+          @short[$1]
+        when /^--([^-]\S*)$/
+          @long[$1]
+        else
+          raise CommandlineError, "invalid argument syntax: '#{arg}'"
+        end
       raise CommandlineError, "unknown argument '#{arg}'" unless sym
 
       if given_args.include?(sym) && !@specs[sym][:multi]
@@ -356,8 +431,6 @@ class Parser
       opts = @specs[sym]
       raise CommandlineError, "option '#{arg}' needs a parameter" if params.empty? && opts[:type] != :flag
 
-      vals["#{sym}_given".intern] = true # mark argument as specified on the commandline
-
       case opts[:type]
       when :flag
         vals[sym] = !opts[:default]
@@ -369,8 +442,6 @@ class Parser
         vals[sym] = params.map { |pg| pg.map { |p| p.to_s } }
       when :io, :ios
         vals[sym] = params.map { |pg| pg.map { |p| parse_io_parameter p, arg } }
-      when :date, :dates
-        vals[sym] = params.map { |pg| pg.map { |p| parse_date_parameter p, arg } }
       end
 
       if SINGLE_ARG_TYPES.include?(opts[:type])
@@ -394,19 +465,56 @@ class Parser
     vals
   end
 
-  def parse_date_parameter param, arg #:nodoc:
-    begin
+  def parse_integer_parameter param, arg #:nodoc:
+    raise CommandlineError, "option '#{arg}' needs an integer" unless param =~ /^\d+$/
+    param.to_i
+  end
+
+  def parse_float_parameter param, arg #:nodoc:
+    raise CommandlineError, "option '#{arg}' needs a floating-point number" unless param =~ FLOAT_RE
+    param.to_f
+  end
+
+  def parse_io_parameter param, arg #:nodoc:
+    case param
+    when /^(stdin|-)$/i; $stdin
+    else
+      require 'open-uri'
       begin
-        time = Chronic.parse(param)
-      rescue NameError
-        # chronic is not available
+        open param
+      rescue SystemCallError => e
+        raise CommandlineError, "file or url for option '#{arg}' cannot be opened: #{e.message}"
       end
-      time ? Date.new(time.year, time.month, time.day) : Date.parse(param)
-    rescue ArgumentError => e
-      raise CommandlineError, "option '#{arg}' needs a date"
     end
   end
 
+  def collect_argument_parameters args, start_at #:nodoc:
+    params = []
+    pos = start_at
+    while args[pos] && args[pos] !~ PARAM_RE && !@stop_words.member?(args[pos]) do
+      params << args[pos]
+      pos += 1
+    end
+    params
+  end
+
+  def width #:nodoc:
+    @width ||= 
+      if $stdout.tty?
+        begin
+          require 'curses'
+          Curses::init_screen
+          x = Curses::cols
+          Curses::close_screen
+          x
+        rescue Exception
+          80
+        end
+      else
+        80
+      end
+  end
+
   ## Print the help message to +stream+.
   def educate stream=$stdout
     width # just calculate it now; otherwise we have to be careful not to
@@ -415,7 +523,7 @@ class Parser
     left = {}
     @specs.each do |name, spec| 
       left[name] = "--#{spec[:long]}" +
-        (spec[:short] && spec[:short] != :none ? ", -#{spec[:short]}" : "") +
+        (spec[:short] ? ", -#{spec[:short]}" : "") +
         case spec[:type]
         when :flag; ""
         when :int; " <i>"
@@ -426,8 +534,6 @@ class Parser
         when :floats; " <f+>"
         when :io; " <filename/uri>"
         when :ios; " <filename/uri+>"
-        when :date; " <date>"
-        when :dates; " <date+>"
         end
     end
 
@@ -472,152 +578,7 @@ class Parser
     end
   end
 
-  def width #:nodoc:
-    @width ||= if $stdout.tty?
-      begin
-        require 'curses'
-        Curses::init_screen
-        x = Curses::cols
-        Curses::close_screen
-        x
-      rescue Exception
-        80
-      end
-    else
-      80
-    end
-  end
-
-  def wrap str, opts={} # :nodoc:
-    if str == ""
-      [""]
-    else
-      str.split("\n").map { |s| wrap_line s, opts }.flatten
-    end
-  end
-
-private
-
-  ## yield successive arg, parameter pairs
-  def each_arg args
-    remains = []
-    i = 0
-
-    until i >= args.length
-      if @stop_words.member? args[i]
-        remains += args[i .. -1]
-        return remains
-      end
-      case args[i]
-      when /^--$/ # arg terminator
-        remains += args[(i + 1) .. -1]
-        return remains
-      when /^--(\S+?)=(.*)$/ # long argument with equals
-        yield "--#{$1}", [$2]
-        i += 1
-      when /^--(\S+)$/ # long argument
-        params = collect_argument_parameters(args, i + 1)
-        unless params.empty?
-          num_params_taken = yield args[i], params
-          unless num_params_taken
-            if @stop_on_unknown
-              remains += args[i + 1 .. -1]
-              return remains
-            else
-              remains += params
-            end
-          end
-          i += 1 + num_params_taken
-        else # long argument no parameter
-          yield args[i], nil
-          i += 1
-        end
-      when /^-(\S+)$/ # one or more short arguments
-        shortargs = $1.split(//)
-        shortargs.each_with_index do |a, j|
-          if j == (shortargs.length - 1)
-            params = collect_argument_parameters(args, i + 1)
-            unless params.empty?
-              num_params_taken = yield "-#{a}", params
-              unless num_params_taken
-                if @stop_on_unknown
-                  remains += args[i + 1 .. -1]
-                  return remains
-                else
-                  remains += params
-                end
-              end
-              i += 1 + num_params_taken
-            else # argument no parameter
-              yield "-#{a}", nil
-              i += 1
-            end
-          else
-            yield "-#{a}", nil
-          end
-        end
-      else
-        if @stop_on_unknown
-          remains += args[i .. -1]
-          return remains
-        else
-          remains << args[i]
-          i += 1
-        end
-      end
-    end
-
-    remains
-  end
-
-  def parse_integer_parameter param, arg
-    raise CommandlineError, "option '#{arg}' needs an integer" unless param =~ /^\d+$/
-    param.to_i
-  end
-
-  def parse_float_parameter param, arg
-    raise CommandlineError, "option '#{arg}' needs a floating-point number" unless param =~ FLOAT_RE
-    param.to_f
-  end
-
-  def parse_io_parameter param, arg
-    case param
-    when /^(stdin|-)$/i; $stdin
-    else
-      require 'open-uri'
-      begin
-        open param
-      rescue SystemCallError => e
-        raise CommandlineError, "file or url for option '#{arg}' cannot be opened: #{e.message}"
-      end
-    end
-  end
-
-  def collect_argument_parameters args, start_at
-    params = []
-    pos = start_at
-    while args[pos] && args[pos] !~ PARAM_RE && !@stop_words.member?(args[pos]) do
-      params << args[pos]
-      pos += 1
-    end
-    params
-  end
-
-  def resolve_default_short_options
-    @order.each do |type, name|
-      next unless type == :opt
-      opts = @specs[name]
-      next if opts[:short]
-
-      c = opts[:long].split(//).find { |d| d !~ INVALID_SHORT_ARG_REGEX && !@short.member?(d) }
-      raise ArgumentError, "can't generate a default short option name for #{opts[:long].inspect}: out of unique characters" unless c
-
-      opts[:short] = c
-      @short[c] = name
-    end
-  end
-
-  def wrap_line str, opts={}
+  def wrap_line str, opts={} # :nodoc:
     prefix = opts[:prefix] || 0
     width = opts[:width] || (self.width - 1)
     start = 0
@@ -637,9 +598,17 @@ private
     ret
   end
 
+  def wrap str, opts={} # :nodoc:
+    if str == ""
+      [""]
+    else
+      str.split("\n").map { |s| wrap_line s, opts }.flatten
+    end
+  end
+
   ## instance_eval but with ability to handle block arguments
   ## thanks to why: http://redhanded.hobix.com/inspect/aBlockCostume.html
-  def cloaker &b
+  def cloaker &b #:nodoc:
     (class << self; self; end).class_eval do
       define_method :cloaker_, &b
       meth = instance_method :cloaker_
@@ -659,12 +628,6 @@ end
 ## (Parser#opt), zero or more calls to +text+ (Parser#text), and
 ## probably a call to +version+ (Parser#version).
 ##
-## The returned block contains a value for every option specified with
-## +opt+.  The value will be the value given on the commandline, or the
-## default value if the option was not specified on the commandline. For
-## every option specified on the commandline, a key "<option
-## name>_given" will also be set in the hash.
-##
 ## Example:
 ##
 ##   require 'trollop'
@@ -675,11 +638,7 @@ end
 ##     opt :num_thumbs, "Number of thumbs", :type => :int # an integer --num-thumbs <i>, defaulting to nil
 ##   end
 ##
-##   ## if called with no arguments
-##   p opts # => { :monkey => false, :goat => true, :num_limbs => 4, :num_thumbs => nil }
-##
-##   ## if called with --monkey
-##   p opts # => {:monkey_given=>true, :monkey=>true, :goat=>true, :num_limbs=>4, :help=>false, :num_thumbs=>nil}
+##   p opts # returns a hash: { :monkey => false, :goat => true, :num_limbs => 4, :num_thumbs => nil }
 ##
 ## See more examples at http://trollop.rubyforge.org.
 def options args = ARGV, *a, &b
@@ -733,3 +692,4 @@ end
 module_function :options, :die
 
 end # module
+