JamieFlournoy-AvantiConveniences 1.0.4

data/History.txt

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

data/README.txt

@@ -0,0 +1,69 @@
+= 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).
+
+HashExtensions currently just adds the Hash#rekey method.
+
+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.
+
+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,74 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/avanti_conveniences.rb'
+
+hoe = Hoe.new('AvantiConveniences', AvantiConveniences::VERSION) do |p|
+    p.developer('Jamie Flournoy', 'jamie@pervasivecode.com')
+    p.extra_deps = [['activesupport', '>= 1.2.6'], ['text-hyphen', '>= 1.0.0']]
+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/avanti_conveniences.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/arg_checks'
+require File.dirname(__FILE__) + '/hash_extensions'
+require File.dirname(__FILE__) + '/string_extensions'
+require File.dirname(__FILE__) + '/text_formatter'
+require File.dirname(__FILE__) + '/uri_extensions'
+
+class AvantiConveniences
+  VERSION = '1.0.4'
+end

data/lib/hash_extensions.rb

@@ -0,0 +1,10 @@
+class Hash
+    unless Hash.new.respond_to? :rekey
+        # Return a copy of this Hash where each key is result of calling the block with each key as the argument.
+        def rekey(&block)
+            rekeyed = {}
+            keys.each{|k| rekeyed[yield(k)] = self[k] }
+            rekeyed
+        end
+    end
+end

data/lib/string_extensions.rb

@@ -0,0 +1,24 @@
+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(/\s/,'').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/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_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_hash_extensions.rb

@@ -0,0 +1,9 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/hash_extensions'
+
+class TestHashExtensions < Test::Unit::TestCase
+    def test_rekey
+        test_data = {{'foo' => 1, 'aBc' => 2}  =>  ['ABC', 'FOO']}
+        test_data.each{|i,o| assert_equal o, i.rekey{|k| k.upcase}.keys.sort }
+    end
+end

data/test/test_string_extensions.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/string_extensions'
+
+class TestStringExtensions < Test::Unit::TestCase
+    def test_dehumanize
+        d = {'Foo' => 'foo',
+             'Foo ' => 'foo',
+             'Foo Bar' => 'foo_bar',
+             'Foo_Bar' => 'foo_bar',
+             "foo\tbar\nbiz \t\n\t \n\t\n baz_ " => 'foo_bar_biz_baz'}
+        d.each{|i,o| assert_equal o, i.dehumanize}
+    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_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,106 @@
+--- !ruby/object:Gem::Specification 
+name: JamieFlournoy-AvantiConveniences
+version: !ruby/object:Gem::Version 
+  version: 1.0.4
+platform: ruby
+authors: 
+- Jamie Flournoy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-20 00:00:00 -07: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: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.11.0
+    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: 
+- 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
+has_rdoc: true
+homepage: http://www.pervasivecode.com/blog/avanticonveniences/
+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.2.0
+signing_key: 
+specification_version: 2
+summary: AvantiConveniences is a set of convenience code for Ruby on Rails applications.
+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