AvantiConveniences 1.0.6

data/AvantiConveniences.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{AvantiConveniences}
+  s.version = "1.0.4"
+
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jamie Flournoy"]
+  s.date = %q{2009-03-20}
+  s.description = %q{AvantiConveniences is a set of convenience code for Ruby on Rails applications.}
+  s.email = ["jamie@pervasivecode.com"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile", "lib/arg_checks.rb", "lib/avanti_conveniences.rb", "lib/hash_extensions.rb", "lib/string_extensions.rb", "lib/text_formatter.rb", "lib/uri_extensions.rb", "test/test_arg_checks.rb", "test/test_avanti_conveniences.rb", "test/test_hash_extensions.rb", "test/test_string_extensions.rb", "test/test_text_formatter.rb", "test/test_uri_extensions.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://www.pervasivecode.com/blog/avanticonveniences/}
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{avanticonveniences}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{AvantiConveniences is a set of convenience code for Ruby on Rails applications.}
+  s.test_files = ["test/test_arg_checks.rb", "test/test_avanti_conveniences.rb", "test/test_hash_extensions.rb", "test/test_string_extensions.rb", "test/test_text_formatter.rb", "test/test_uri_extensions.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 1.2.6"])
+      s.add_runtime_dependency(%q<text-hyphen>, [">= 1.0.0"])
+      s.add_development_dependency(%q<hoe>, [">= 1.11.0"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 1.2.6"])
+      s.add_dependency(%q<text-hyphen>, [">= 1.0.0"])
+      s.add_dependency(%q<hoe>, [">= 1.11.0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 1.2.6"])
+    s.add_dependency(%q<text-hyphen>, [">= 1.0.0"])
+    s.add_dependency(%q<hoe>, [">= 1.11.0"])
+  end
+end

data/History.txt

@@ -0,0 +1,32 @@
+=== 1.0.6 / 2009-12-22
+
+* Added Array#average, Die.roll, Float::INFINITY, Time#at_midnight
+* Updated to use Hoe 2.0.
+
+=== 1.0.5 / 2009-07-27
+
+* Added Hash#map_keys, Hash#map_values, and Hash#map_pairs.
+
+=== 1.0.4 / 2009-03-20
+
+* Fixed the 'rcov' Rake task so it worked with the latest Hoe.
+* Added a bit of documentation that was missing.
+
+=== 1.0.3 / 2008-11-11
+
+* Bug fix for a hang in TextFormatter.hyphenate_word, when given a wprd that contains multiple hyphens.
+
+=== 1.0.2 / 2008-09-29
+
+* Made TextFormatter.split_long_words take a fourth optional argument to control insertion of newlines in split text.
+
+=== 1.0.1 / 2008-08-30
+
+* Changed the output of ArgChecks.arg_type so that it includes the to_s representation of the object itself in the exception message.
+* Added ArgChecks.arg_responds_to.
+
+=== 1.0.0 / 2008-08-04
+
+* First release.
+
+  * Birthday!

data/Manifest.txt

@@ -0,0 +1,26 @@
+AvantiConveniences.gemspec
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/arg_checks.rb
+lib/array_extensions.rb
+lib/avanti_conveniences.rb
+lib/die.rb
+lib/float_extensions.rb
+lib/hash_extensions.rb
+lib/string_extensions.rb
+lib/text_formatter.rb
+lib/time_extensions.rb
+lib/uri_extensions.rb
+test/test_arg_checks.rb
+test/test_array_extensions.rb
+test/test_avanti_conveniences.rb
+test/test_die.rb
+test/test_float_extensions.rb
+test/test_hash_extensions.rb
+test/test_string_extensions.rb
+test/test_text_formatter.rb
+test/test_time_extensions.rb
+test/test_uri_extensions.rb
+

data/README.txt

@@ -0,0 +1,80 @@
+= AvantiConveniences
+
+http://www.pervasivecode.com/blog/avanticonveniences/
+Author: Jamie Flournoy (jamie@pervasivecode.com)
+
+== DESCRIPTION:
+
+AvantiConveniences is a set of convenience code for Ruby on Rails applications.
+
+== FEATURES/PROBLEMS:
+
+ArgChecks helps you implement simple sanity-checking of arguments, like
+permanent assertions or a poor man's Design by Contract facility, so you can
+write code that will Fail Fast (see http://c2.com/cgi/wiki?FailFast).
+
+ArrayExtensions adds Array#average.
+
+Die adds Die.roll which is semantic sugar around rand(n).
+
+FloatExtensions adds Float::INFINITY, which is semantic sugar for people
+who don't want to see '1.0 / 0' in your code.
+
+HashExtensions adds a few methods that help you easily replace all the keys
+and/or values at once.
+
+StringExtensions provides String quoting (not escaping) with single quotes,
+double quotes, or a caller-specified quoting character, and a String#dehumanize
+method to do the reverse of the String#humanize method provided by ActiveSupport.
+
+TextFormatter provides methods for hyphenating words for word-wrapping.
+
+TimeExtensions provides Time#at_midnight, which is useful if you want to work
+with a lot of timestamps that need to be bucketed by day.
+
+URIExtensions provides URI::Generic#query_from_hash, which will create a URI
+query string from a Hash.
+
+== SYNOPSIS:
+
+See individual classes for details. All of them are single method invocations
+that are very simple to use. For additional examples look in the test/
+directory.
+
+== REQUIREMENTS:
+
+Ruby 1.8.5 (might work with earlier versions), ActiveSupport 1.2.6, Text-Hyphen
+1.0.0, and Hoe 1.7.0.
+
+== INSTALL:
+
+If you haven't done this before: 
+  gem sources -a http://gems.github.com
+
+Then: 
+  sudo gem install JamieFlournoy-AvantiConveniences
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Pervasive Code
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,77 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+# Hoe::plugin :gemcutter
+
+hoe = Hoe.spec 'AvantiConveniences' do
+    developer('Jamie Flournoy', 'jamie@pervasivecode.com')
+    extra_deps << ['activesupport', '>= 1.2.6']
+    extra_deps << ['text-hyphen', '>= 1.0.0']
+    extra_dev_deps << ['thoughtbot-shoulda', '>= 2.10.1']
+end
+
+task :gemspec do
+  File.open("#{hoe.name}.gemspec", "w") {|f| f << hoe.spec.to_ruby }
+end
+task :package => :gemspec
+
+
+# The rcov task in this file worked until Hoe was updated; this code keeps the old behavior
+# and disables Hoe's rcov task.
+Rake::TaskManager.class_eval do
+  def remove_task(task_name)
+    @tasks.delete(task_name.to_s)
+  end
+end
+def remove_task(task_name)
+  Rake.application.remove_task(task_name)
+end
+remove_task 'rcov'
+
+
+task :rcov do
+    sh 'rcov test/test_*.rb'
+end
+task :clean_rcov do
+    sh 'rm -rf ./coverage/*'
+end
+task :clean => [:clean_rcov]
+
+
+# vim: syntax=Ruby
+
+
+# stats
+begin
+    gem 'rails'
+    require 'code_statistics'
+    namespace :spec do
+        desc "Use Rails's rake:stats task for a gem"
+        task :statsetup do
+            class CodeStatistics
+                def calculate_statistics
+                    @pairs.inject({}) do |stats, pair|
+                        if 3 == pair.size
+                            stats[pair.first] = calculate_directory_statistics(pair[1], pair[2]); stats
+                        else
+                            stats[pair.first] = calculate_directory_statistics(pair.last); stats
+                        end
+                    end
+                end
+            end
+            ::STATS_DIRECTORIES = [['Libraries',   'lib',  /\.(sql|rhtml|erb|rb|yml)$/],
+                                   ['Tests',       'test', /\.(sql|rhtml|erb|rb|yml)$/]]
+            ::CodeStatistics::TEST_TYPES << "Tests"
+        end
+    end
+    desc "Report code statistics (KLOCs, etc) from the application"
+    task :stats => "spec:statsetup" do
+        CodeStatistics.new(*STATS_DIRECTORIES).to_s
+    end
+rescue Gem::LoadError => le
+    task :stats do
+        raise RuntimeError, "'rails' gem not found - you must install it in order to use this task.\n"
+    end
+end

data/lib/arg_checks.rb

@@ -0,0 +1,79 @@
+# Include this module in your classes that need sanity checking of method arguments.
+# If any of these checks is not satisfied, it will raise an ArgumentError with a
+# detailed message about what went wrong.
+module ArgChecks
+    # Require that all arguments be of the specified class, or one of its subclasses (uses is_a?).
+    # Consider using arg_responds_to? or respond_to? instead, to make your API more flexible.
+    def arg_type(klass, *args)
+        raise ArgumentError, "First argument must be a class. Got #{klass.to_s}" unless klass.is_a? Class
+        args.each{|obj| raise ArgumentError, "Wrong type for argument '#{obj}' (should be #{klass})" unless obj.is_a? klass }
+    end
+  
+    # Require that all arguments respond_to? the specified method.
+    def arg_responds_to(method, *args)
+        arg_type Symbol, method
+        args.each{|obj| raise ArgumentError, "Object #{obj} (class #{obj.class}) doesn't respond to #{method}." unless obj.respond_to? method}
+    end
+  
+    # Require that all arguments be non-nil.
+    def arg_required(*args)
+        args.each{|obj| raise ArgumentError, "Argument cannot be nil" if obj.nil? }
+    end
+    
+    # Require that the second argument be non-nil. Upon failure the first argument is used in the error message.
+    def named_arg_required(name, obj)
+        named_arg_required('name', name) unless name.eql?('name')
+        raise ArgumentError, "Argument \"#{name}\" cannot be nil" if obj.nil?
+    end
+    
+    # Require that all values in the hash be non-nil. Returns the list of all keys whose values were nil.
+    def named_args_required(obj_hash)
+        keys_with_nil_values = obj_hash.select{|k,v| v.nil?}.collect{|e| e[0]}
+        raise ArgumentError, "Nil argument not allowed in #{keys_with_nil_values.join(', ')}" unless keys_with_nil_values.empty?
+    end
+    
+    # Require that all arguments be greater than or equal to max.
+    def arg_max(max, *args)
+        args.each{|obj| raise ArgumentError, "Argument exceeds maxmimum value (max is #{max.to_s})" unless max >= obj}
+    end
+    
+    # Require that all arguments be less than or equal to min.
+    def arg_min(min, *args)
+        args.each{|obj| raise ArgumentError, "Argument is lower than minimum value (min is #{min.to_s})" unless min <= obj }
+    end
+
+    # Require that all arguments return a set of keys containing at least the specified elements.
+    def arg_hash_keys_required(required_keys, *args)
+        args.each do |h|
+            missing = required_keys - h.keys
+            raise ArgumentError, "Hash is missing required keys (#{missing.join(', ')}). Got:\n#{h.inspect}" if missing.length > 0
+        end
+    end
+
+    # Require that all arguments return a set of keys containing exactly the specified elements.
+    def arg_hash_keys_exact(exact_keys, *args)
+        args.each do |h|
+            missing = exact_keys - h.keys
+            extra = h.keys - exact_keys
+            raise ArgumentError, "Hash keys don't match required set (#{exact_keys.join(', ')}). " +
+                "Missing required keys (#{missing.join(', ')}); extra keys not allowed (#{extra.join(', ')}).\n" +
+                "Got:\n#{h.inspect}" if (missing.length > 0) || (extra.length >0)
+        end
+    end
+
+    # Require that all arguments return a set of keys containing a set of required keys, zero or more of the optional keys, and nothing else.
+    def arg_hash_keys_limit(required_keys, optional_keys, *args)
+        args.each do |h|
+          missing = required_keys - h.keys
+          extra = h.keys - required_keys - optional_keys
+      
+          unless missing.empty? && extra.empty?
+              msg = ""
+              msg << "Hash is missing required keys (#{missing.join(', ')}).\n" unless missing.empty?
+              msg << "Hash has extra keys which aren't allowed (#{extra.join(', ')}).\n" unless extra.empty?
+              msg << " Got: #{h.inspect}"
+              raise ArgumentError, msg
+          end
+        end
+    end
+end

data/lib/array_extensions.rb

@@ -0,0 +1,5 @@
+class Array
+  def average
+    self.sum / self.size
+  end
+end

data/lib/avanti_conveniences.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/arg_checks'
+require File.dirname(__FILE__) + '/array_extensions'
+require File.dirname(__FILE__) + '/die'
+require File.dirname(__FILE__) + '/float_extensions'
+require File.dirname(__FILE__) + '/hash_extensions'
+require File.dirname(__FILE__) + '/string_extensions'
+require File.dirname(__FILE__) + '/text_formatter'
+require File.dirname(__FILE__) + '/time_extensions'
+require File.dirname(__FILE__) + '/uri_extensions'
+
+class AvantiConveniences
+  VERSION = '1.0.6'
+end

data/lib/die.rb

@@ -0,0 +1,5 @@
+class Die
+  def Die.roll(sides)
+    (rand * sides).to_i + 1
+  end
+end

data/lib/float_extensions.rb

@@ -0,0 +1,3 @@
+class Float
+  INFINITY = 1.0 / 0
+end

data/lib/hash_extensions.rb

@@ -0,0 +1,22 @@
+class Hash
+  # Call a block for every key in the Hash, and replace each key with the block's return value.
+  # This returns a new Hash, so you do not need to call #rehash on it.
+  def map_keys(&block)
+    Hash[* self.to_a.map{|k,v| [yield(k), v] }.flatten ]
+  end
+  alias_method :rekey, :map_keys  unless Hash.new.respond_to? :rekey
+
+  # Call a block for every value in the Hash, and replace each value with the block's return value.
+  def map_values(&block)
+    Hash[* self.to_a.map{|k,v| [k, yield(v)] }.flatten ]
+  end
+  alias_method :revalue, :map_keys unless Hash.new.respond_to? :revalue
+
+  # Call a block for every (key, value) pair in the hash, passing them in as a 2-element Array.
+  # The block should return a similar 2-element array of (key, value) which will be used to replace
+  # the original key and value.
+  def map_pairs(&block)
+    Hash[* self.to_a.map{|k,v| yield(k,v) }.flatten ]
+  end
+
+end

data/lib/string_extensions.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+gem 'activesupport', '>= 1.2.6'
+require 'active_support' # for titleize
+
+class String
+    # Convert a string consisting of whitespace separated words into an underscore-delimited
+    # set of lowercase words. This is the opposite of what ActiveSupport's String.humanize
+    # method docs.
+    # Example: 'Foo Bar' -> 'foo_bar'
+    def dehumanize
+        titleize.gsub(/\W+/,'_').gsub(/\s+/,'_').gsub(/^_+|_+$/,'').underscore
+    end
+
+    # Return this string, surrounded by quote_char on either side.
+    def quote(quote_char)
+        "#{quote_char}#{self}#{quote_char}"
+    end
+    
+    # Return this string, surrounded by a single quote (') on either side.
+    def single_quote; self.quote("'"); end
+    
+    # Return this string, surrounded by a double quote (") on either side.
+    def double_quote; self.quote('"'); end
+
+end

data/lib/text_formatter.rb

@@ -0,0 +1,83 @@
+require 'rubygems'
+
+# Note: Text::Hyphen 1.0.0 uses attr_accessor in a couple of places
+# where it should use attr_reader, because a setter is defined 
+# immediately afterward; this causes 'method redefined' warnings
+# when running 'rake test' since the Hoe gem enables the ruby -w flag.
+# To fix this warning, Text::Hyphen must be fixed. so...
+# TODO patch Text::Hyphen to fix the 'method redefined' warnings.
+gem 'text-hyphen', '>= 1.0.0'
+require 'text/hyphen'
+
+# Several methods take a language_code argument. This is the language code
+# (like 'en_us') required by Text::Hyphen.
+class TextFormatter
+    # Replace all words longer than max_width with the results of split_word.
+    # Leading and trailing whitespace is eliminated and inline whitespace runs are replaced with a space.
+    def split_long_words(string, max_width, language_code, append_newlines = false)
+        words = string.split
+        words.collect{|w| w.length > max_width ? split_word(w, max_width, language_code, append_newlines) : w}.flatten.join(' ')
+    end
+    
+    # Split one word and return it as an array of substrings no longer than the specified size.
+    # Splitting results consist of a hyphenated version (if possible) or by cutting the word into
+    # segments no longer than max_width (if hyphenation fails, such as for the word 'xxxxxxxxxxx')
+    # Every substring except the last will have a newline appended unless append_newlines is false.
+    # The result for a 'word' string containing whitespace is undefined.
+    def split_word(word, size, langauge_code, append_newlines = true)
+        hyphenated = hyphenate_word(word,size,langauge_code)
+        hyphenated_chopped = hyphenated.collect{|w| w.length > size ? chop_word(w, size) : w}.flatten
+        if append_newlines
+            hyphenated_chopped.collect!{|w| "#{w}\n"} 
+            hyphenated_chopped.last.chop!
+        end
+        return hyphenated_chopped
+    end
+    
+    # Try to hyphenate a word into chunks just barely short enough to fit within the specified size
+    def hyphenate_word(word, size, language_code)
+        # handle pre-hyphenated words, which hyphenate_to balks on
+        hyphenated = word.split(/-/)
+        if hyphenated.size > 1
+            hyphenated.collect!{|w| w.length > size ? self.hyphenate_word(w, size, language_code) : w}
+            hyphenated.flatten!
+            last = hyphenated.pop
+            hyphenated.collect!{|w| w[-1,1].eql?('-') ? w : "#{w}-"}
+            hyphenated.push(last)
+            return hyphenated
+        end
+
+        h = TextFormatter.text_hyphenator(language_code)
+        hyphenated = h.hyphenate_to(word, size).compact
+
+        loop_limit = word.length
+        while (hyphenated.size > 1 && hyphenated.last.length > size) do
+            last = hyphenated.pop
+            part1, part2 = h.hyphenate_to(last, size).compact
+            hyphenated.push(part1)
+            hyphenated.push(part2) unless part2.nil?
+
+            loop_limit -= 1
+            break if last.eql?(part1) || (loop_limit < 0)
+        end
+        return hyphenated
+    end
+    
+    # Simply chop overly long "words" into chunks no longer than the specified size
+    def chop_word(word, size)
+        chopped = []
+        while (!word.nil? && word.length > size) do
+            chopped.push word[0,size]
+            word = word[size..-1]
+        end
+        chopped.push(word) # get the last chunk
+        return chopped
+    end
+
+    # Get a Text::Hyphen instance for a specified language
+    def TextFormatter.text_hyphenator(language_code)
+        @@hyphenators = Hash.new unless defined? @@hyphenators
+        @@hyphenators[language_code] ||= Text::Hyphen.new(:language => language_code, :left => 2, :right => 2)
+        return @@hyphenators[language_code]
+    end
+end

data/lib/time_extensions.rb

@@ -0,0 +1,6 @@
+class Time
+  def at_midnight
+    Time.mktime(self.year, self.month, self.day, 0, 0, 0)
+  end
+end
+

data/lib/uri_extensions.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+gem 'activesupport'
+require 'active_support/core_ext/hash/indifferent_access'
+
+require 'uri'
+require File.dirname(__FILE__) + '/hash_extensions'
+
+class URI::Generic
+    # Create a URI query string from a Hash. The keys in the returned query string
+    # are sorted for easier testing.
+    # Example: {:foo => 'bar', :biz => 'b a z'} -> '?biz=b%20a%20z&foo=bar'
+    def self.query_from_hash(q_hash)
+        return '' if q_hash.nil?
+
+        # Reveal cases where the caller thought they were using HashWithIndifferentAccess
+        # but actually they used Hash and probably got duplicate keys (:foo vs 'foo')
+        q_hash = q_hash.rekey{|k| k.is_a?(Symbol) ? ":#{k}" : k} unless q_hash.is_a?(HashWithIndifferentAccess)
+
+        pairs = []
+        q_hash.each_pair{|k,v| pairs << "#{k}=#{URI.escape(v.to_s)}" unless v.nil?}
+        '?' + pairs.sort.join('&')
+    end
+end

data/test/test_arg_checks.rb

@@ -0,0 +1,113 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/arg_checks'
+
+class TestArgChecks < Test::Unit::TestCase
+  include ArgChecks
+
+  def test_arg_type
+    assert_nothing_raised(ArgumentError) { arg_dummy('s', 3.0) }
+    assert_raise(ArgumentError) { arg_dummy('s', 3) }
+    assert_raise(ArgumentError) { arg_dummy('blah blah', 'x') }
+    assert_raise(ArgumentError) { arg_dummy(3.0, 3.0) }
+
+    assert_nothing_raised(ArgumentError) { arg_dummy2('s', -1.0, 10.0, 'x') }
+    assert_raise(ArgumentError) { arg_dummy2(-1.0, 10.0, 'x', 'blah') }
+  end
+
+  def test_arg_required
+    assert_raise(ArgumentError) { arg_dummy5(nil, nil) }
+    assert_raise(ArgumentError) { arg_dummy5(nil, 3.0) }
+    assert_raise(ArgumentError) { arg_dummy5('blah', nil) }
+    assert_nothing_raised(ArgumentError) { arg_dummy5('blah', 3.0) }
+  end
+  
+  def arg_dummy5(arg1, arg2)
+      arg_required arg1, arg2
+  end
+
+  def arg_dummy(arg1_string, arg2_float)
+    arg_type String, arg1_string
+    arg_type Float, arg2_float
+  end
+
+  def arg_dummy2(arg1_string, arg2_float, arg3_float, arg4_string)
+    arg_type String, arg1_string, arg4_string
+    arg_type Float, arg2_float, arg3_float
+  end
+  
+  def test_arg_min
+    assert_raise(ArgumentError) {arg_dummy3(5, 'z')}
+    assert_raise(ArgumentError) {arg_dummy3(100, 'x')}
+    assert_nothing_raised(ArgumentError) {arg_dummy3(100, 'z')}
+  end
+
+  def arg_dummy3(arg1, arg2)
+    arg_min 6, arg1
+    arg_min 'y', arg2
+  end
+    
+  def test_arg_max
+    assert_raise(ArgumentError) {arg_dummy4(100, 'z')}
+    assert_raise(ArgumentError) {arg_dummy4(5, 'z')}
+    assert_nothing_raised(ArgumentError) {arg_dummy4(5, 'x')}
+  end
+
+  def arg_dummy4(arg1, arg2)
+    arg_max 6, arg1
+    arg_max 'y', arg2
+  end
+
+    @@hash = {'k1' => 'v1', 'k2'=>'v2'}
+
+    def test_arg_hash_keys_exact
+        assert_nothing_raised(ArgumentError) { arg_hash_keys_exact %w{k1 k2}, @@hash }
+
+        assert_raise(ArgumentError) { arg_hash_keys_exact %w{k1},       @@hash}
+        assert_raise(ArgumentError) { arg_hash_keys_exact %w{k2},       @@hash }
+        assert_raise(ArgumentError) { arg_hash_keys_exact %w{k1 k2 k3}, @@hash }
+    end
+  
+    def test_arg_hash_keys_required
+        assert_nothing_raised(ArgumentError) { arg_hash_keys_required %w{k1 k2}, @@hash }
+        assert_nothing_raised(ArgumentError) { arg_hash_keys_required %w{k1},    @@hash }
+        assert_nothing_raised(ArgumentError) { arg_hash_keys_required %w{k2},    @@hash }
+    
+        assert_raise(ArgumentError) { arg_hash_keys_required %w{k1 k2 k3}, @@hash }   
+    end
+
+    def test_arg_hash_keys_limit
+        assert_nothing_raised(ArgumentError) { arg_hash_keys_limit %w{k1 k2},   %w{k3},       @@hash }
+        assert_nothing_raised(ArgumentError) { arg_hash_keys_limit %w{k1},      %w{k2 k3},    @@hash }
+        assert_nothing_raised(ArgumentError) { arg_hash_keys_limit %w{k2},      %w{k1 k3},    @@hash }
+        assert_nothing_raised(ArgumentError) { arg_hash_keys_limit [],          %w{k1 k2 k3}, @@hash }
+    
+        assert_raise(ArgumentError) { arg_hash_keys_limit %w{k1 k2 k3}, [],         @@hash }
+        assert_raise(ArgumentError) { arg_hash_keys_limit %w{k1 k3},    %w{k2},     @@hash }   
+        assert_raise(ArgumentError) { arg_hash_keys_limit %w{k3},       %w{k1, k2}, @@hash }
+        assert_raise(ArgumentError) { arg_hash_keys_limit [],           [],         @@hash }
+    end
+    
+    def test_named_arg_required
+        assert_nothing_raised(ArgumentError){ named_arg_required('foo', 1) }
+        assert_raise(ArgumentError){ named_arg_required('bar', nil) }
+    end
+
+    def test_named_args_required
+        assert_nothing_raised(ArgumentError){ named_args_required({}) }
+        assert_nothing_raised(ArgumentError){ named_args_required(:foo => 1) }
+        assert_raise(ArgumentError){ named_args_required(:bar => nil) }
+        assert_raise(ArgumentError){ named_args_required(:foo => 1, :bar => nil) }
+    end
+
+  def test_arg_respond_to
+    assert_nothing_raised(ArgumentError) { arg_dummy6(:round, 1.1) }
+    assert_nothing_raised(ArgumentError) { arg_dummy6(:round, Float::EPSILON) }
+    assert_raise(ArgumentError) { arg_dummy6(:round, 'a') }
+    assert_raise(ArgumentError) { arg_dummy6(:round, [0]) }
+    assert_raise(ArgumentError) { arg_dummy6(:round, Object) }
+  end
+
+  def arg_dummy6(arg1, arg2)
+      arg_responds_to arg1, arg2
+  end
+end

data/test/test_array_extensions.rb

@@ -0,0 +1,36 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/array_extensions'
+require 'shoulda'
+
+module StringMath
+  def +(other)
+    result = super(other)
+    result.extend StringMath
+    result
+  end
+  
+  def /(denominator)
+    chunk_size = (self.size.to_f / denominator).to_i
+    self[0..(chunk_size - 1)]
+  end
+end
+
+
+class TestArrayExtensions < Test::Unit::TestCase
+
+  context 'Array.average' do
+    should 'return the average of 3 integers' do
+      assert_equal 5, [1,3,11].average
+    end
+
+    should 'return the average of 3 floats' do
+      assert_equal 5.21, [1.1, 3.3, 11.23].average
+    end
+    
+    should 'work on anything that supports +  and / operators' do
+      test_data = [1,3,11].map{|n| ('x' * n).extend StringMath}
+      assert_equal 'xxxxx', test_data.average
+    end
+  end
+
+end

data/test/test_avanti_conveniences.rb

@@ -0,0 +1,9 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/avanti_conveniences'
+
+class TestAvantiConveniences < Test::Unit::TestCase
+    def test_version
+        assert defined? AvantiConveniences::VERSION
+        assert_not_nil AvantiConveniences::VERSION
+    end
+end

data/test/test_die.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/die'
+require 'shoulda'
+
+class TestDie < Test::Unit::TestCase
+
+  context 'Die.roll' do
+    setup do
+      seed = 1234567890 
+      srand(seed)
+      @expected_rand = rand
+      srand(seed)
+    end
+
+    should 'return a value between 1 and the number of sides' do
+      sides = 1000
+      expected = (@expected_rand * sides + 1).to_i
+      assert_equal expected, Die.roll(sides)
+    end
+  end
+
+end

data/test/test_float_extensions.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/float_extensions'
+require 'shoulda'
+
+class TestFloatExtensions < Test::Unit::TestCase
+
+  context 'Float::INFINITY' do
+    should 'be greater than 10**100' do
+      assert Float::INFINITY > 10**100
+    end
+    should 'be equal to the absolute value of negative infinity' do
+      negative_infinity = -1.0 / 0
+      assert_equal negative_infinity.abs, Float::INFINITY
+    end
+  end
+
+end

data/test/test_hash_extensions.rb

@@ -0,0 +1,23 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/hash_extensions'
+
+class TestHashExtensions < Test::Unit::TestCase
+  def test_map_keys
+    expected = {10 => :a, 20 => :b}
+    actual = {1 => :a, 2 => :b}.map_keys{|k| k * 10}
+    assert_equal expected, actual
+  end
+    
+  def test_map_values
+    expected = {:a => 10, :b => 20}
+    actual = {:a => 1, :b => 2}.map_values{|k| k * 10}
+    assert_equal expected, actual
+  end
+    
+  def test_map_pairs
+    expected = {'A' => 10, 'B' => 20}
+    actual = {'a' => 1, 'b' => 2}.map_pairs{|k, v| [k.upcase, v * 10] }
+    assert_equal expected, actual
+  end
+    
+end

data/test/test_string_extensions.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/string_extensions'
+require 'shoulda'
+
+gem 'activesupport', '>= 1.2.6'
+require 'active_support' # for .humanize
+
+class TestStringExtensions < Test::Unit::TestCase
+  context 'String#dehumanize' do
+    [ ['Hello, World', 'hello_world'],
+      ['$$$123#456',   '123_456'],
+      ['a_b_c_',       'a_b_c'],
+      ['/etc/passwd',  'etc_passwd'],
+      ['Foo',          'foo'],
+      ['Foo Bar',      'foo_bar'],
+      ['Foo_Bar',      'foo_bar'],
+      ["foo\tbar\nbiz \t\n\t \n\t\n baz_ ", 'foo_bar_biz_baz'],
+    ].each do |input, expected|
+      should("convert #{input} into #{expected}") do
+        assert_equal expected, input.dehumanize
+      end
+    end
+
+    %w{1 x hello_world 123_456 foo_bar}.each do |round_trippable|
+      should "undo humanize(#{round_trippable})" do
+        assert_equal round_trippable, round_trippable.humanize.dehumanize
+      end
+    end
+    
+    ['1', 'X', 'A herring', 'Hello world'].each do |rehumanizable|
+      should "return a value for #{rehumanizable} that humanize can undo correctly" do
+        assert_equal rehumanizable, rehumanizable.dehumanize.humanize
+      end
+      
+    end
+
+
+  end
+
+  def test_quote
+    d = {'Foo' => '~Foo~',
+         'Foo~' => '~Foo~~',
+         'Foo Bar' => '~Foo Bar~'}
+    d.each{|i,o| assert_equal o, i.quote('~')}
+  end
+
+  def test_single_quote
+    d = {'Foo Bar' => "'Foo Bar'"}
+    d.each{|i,o| assert_equal o, i.single_quote}
+  end
+
+  def test_double_quote
+    d = {'Foo Bar' => '"Foo Bar"'}
+    d.each{|i,o| assert_equal o, i.double_quote}
+  end
+
+end

data/test/test_text_formatter.rb

@@ -0,0 +1,81 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/text_formatter'
+
+class TestTextFormatter < Test::Unit::TestCase
+    def setup
+        @tf = TextFormatter.new
+    end   
+
+    def test_chop_word_1
+        assert_equal %w{xxx xxx xxx x}, @tf.chop_word('xxxxxxxxxx', 3)
+    end
+    def test_chop_word_2
+        assert_equal %w{xxx xx}, @tf.chop_word('xxxxx', 3)
+    end
+    def test_chop_word_3
+        assert_equal %w{xx}, @tf.chop_word('xx', 3)
+    end
+
+    def test_hyphenate_word_1
+        assert_equal ["Hobo-", 'ken'], @tf.hyphenate_word('Hoboken',5,'en_us')
+    end
+    def test_hyphenate_word_2
+        assert_equal ["spectac-", 'ular'], @tf.hyphenate_word('spectacular',8,'en_us')
+    end
+    def test_hyphenate_word_3
+        assert_equal ["antidisestab-","lishmentarian-","ism"], @tf.hyphenate_word('antidisestablishmentarianism', 15, 'en_us')
+    end
+    def test_hyphenate_word_4
+        x = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+        assert_equal [x], @tf.hyphenate_word(x, 5, 'en_us')
+    end
+    
+    # Real words
+    def test_split_word_1
+        assert_equal ["Hobo-\n", 'ken'], @tf.split_word('Hoboken',5,'en_us')
+    end
+    def test_split_word_2
+        assert_equal ["spectac-\n", 'ular'], @tf.split_word('spectacular',8,'en_us')
+    end
+    def test_split_word_3
+        assert_equal ["spectac-", 'ular'], @tf.split_word('spectacular',8,'en_us', false)
+    end
+    def test_split_word_4
+        assert_equal ["antidisestab-\n","lishmentarian-\n","ism"], @tf.split_word('antidisestablishmentarianism', 15, 'en_us')
+    end
+    def test_split_word_5
+        assert_equal ["antidisestab-","lishmentarian-","ism"], @tf.split_word('antidisestablishmentarianism', 15, 'en_us', false)
+    end
+
+    # long strings get chopped
+    def test_split_word_6
+        x = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+        split_x = []
+        15.times{split_x.push("xxxxx\n")}
+        split_x.push('x')
+        assert_equal split_x, @tf.split_word(x, 5, 'en_us')
+    end
+
+    # pre-hyphenated words should be easy to handle
+    def test_split_word_7
+        assert_equal ["prepared-","from-","recipe"], @tf.split_word('prepared-from-recipe', 15, 'en_us', false)
+    end
+    def test_split_word_8
+        assert_equal ["pre-","pared-","from-","recipe"], @tf.split_word('prepared-from-recipe', 6, 'en_us', false)
+    end
+    
+    def test_split_long_words_1
+        assert_equal "Hobo- ken", @tf.split_long_words('Hoboken',5,'en_us')
+    end
+    def test_split_long_words_2
+        assert_equal "spectac- ular", @tf.split_long_words('spectacular',8,'en_us')
+    end
+    def test_split_long_words_3
+        assert_equal "antidisestab- lishmentarian- ism", @tf.split_long_words('antidisestablishmentarianism', 15, 'en_us')
+    end
+    def test_split_long_words_4
+        i = ["Hoboken      New Jersey \n\n    \t is a\t \nnice \n\t\n\t place.",5,'en_us']
+        o = "Hobo- ken New Jer- sey is a nice place ."
+        assert_equal o, @tf.split_long_words(*i)
+    end
+end

data/test/test_time_extensions.rb

@@ -0,0 +1,23 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/array_extensions'
+require 'shoulda'
+
+gem 'activesupport', '>= 1.2.6'
+require 'active_support' # for .hour, .hours, .second
+
+class TestArrayExtensions < Test::Unit::TestCase
+
+  context 'Time#at_midnight' do
+    [ ['2009-12-01 01:00:00', 1.hour                ],
+      ['2009-12-01 00:00:00', 0                     ],
+      ['2009-12-01 23:59:59', (24.hours - 1.second) ],
+    ].each do |input, expected|
+      should "be #{expected} seconds before #{input}" do
+        t = Time.parse(input)
+        assert_equal expected, t - t.at_midnight
+      end
+    end
+  end
+
+
+end

data/test/test_uri_extensions.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/uri_extensions'
+
+class TestUriExtensions < Test::Unit::TestCase
+    def test_uri_generic_query_from_hash
+        assert_equal '?a=1&b=2', URI::Generic.query_from_hash('a'=>1, 'b'=>2)
+        assert_equal '?:a=1&a=11&b=2', URI::Generic.query_from_hash(:a=>1, 'b'=>2, 'a'=>11)
+        assert_equal '?biz=b%20a%20z&foo=bar', URI::Generic.query_from_hash('foo' => 'bar', 'biz' => 'b a z')
+
+        h = HashWithIndifferentAccess.new
+        h.merge! :a=>1, :b=>2
+        assert_equal '?a=1&b=2', URI::Generic.query_from_hash(h)
+    end
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification 
+name: AvantiConveniences
+version: !ruby/object:Gem::Version 
+  version: 1.0.6
+platform: ruby
+authors: 
+- Jamie Flournoy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-22 00:00:00 -08: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: 1.2.6
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: text-hyphen
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.10.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.3
+    version: 
+description: AvantiConveniences is a set of convenience code for Ruby on Rails applications.
+email: 
+- jamie@pervasivecode.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- AvantiConveniences.gemspec
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/arg_checks.rb
+- lib/array_extensions.rb
+- lib/avanti_conveniences.rb
+- lib/die.rb
+- lib/float_extensions.rb
+- lib/hash_extensions.rb
+- lib/string_extensions.rb
+- lib/text_formatter.rb
+- lib/time_extensions.rb
+- lib/uri_extensions.rb
+- test/test_arg_checks.rb
+- test/test_array_extensions.rb
+- test/test_avanti_conveniences.rb
+- test/test_die.rb
+- test/test_float_extensions.rb
+- test/test_hash_extensions.rb
+- test/test_string_extensions.rb
+- test/test_text_formatter.rb
+- test/test_time_extensions.rb
+- test/test_uri_extensions.rb
+has_rdoc: true
+homepage: http://www.pervasivecode.com/blog/avanticonveniences/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: avanticonveniences
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: AvantiConveniences is a set of convenience code for Ruby on Rails applications.
+test_files: 
+- test/test_arg_checks.rb
+- test/test_array_extensions.rb
+- test/test_avanti_conveniences.rb
+- test/test_die.rb
+- test/test_float_extensions.rb
+- test/test_hash_extensions.rb
+- test/test_string_extensions.rb
+- test/test_text_formatter.rb
+- test/test_time_extensions.rb
+- test/test_uri_extensions.rb