assistance 0.0.1

data/CHANGELOG

@@ -0,0 +1,9 @@
+=== 0.0.1 (2008-01-10)
+
+* Imported #blank? from DataMapper.
+
+* Imported inflector from Merb.
+
+* Imported ConnectionPool from Sequel.
+
+* Imported time calculations from Sequel.

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2008 Ezra Zygmuntowicz, Sam Smoot, Sharon Rosner
+
+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 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,118 @@
+require "rake"
+require "rake/clean"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+require "fileutils"
+include FileUtils
+
+##############################################################################
+# Configuration
+##############################################################################
+NAME = "assistance"
+VERS = "0.0.1"
+CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
+RDOC_OPTS = [
+  "--quiet", 
+  "--title", "Assistance: light-weight application support",
+  "--opname", "index.html",
+  "--line-numbers", 
+  "--main", "README",
+  "--inline-source"
+]
+
+##############################################################################
+# RDoc
+##############################################################################
+task :doc => [:rdoc]
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = "doc/rdoc"
+  rdoc.options += RDOC_OPTS
+  rdoc.main = "README"
+  rdoc.title = "Assistance: light-weight application support"
+  rdoc.rdoc_files.add ["README", "COPYING", "lib/assistance.rb", "lib/**/*.rb"]
+end
+
+##############################################################################
+# Gem packaging
+##############################################################################
+desc "Packages up Assistance."
+task :default => [:package]
+task :package => [:clean]
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.rubyforge_project = NAME
+  s.version = VERS
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"]
+  s.rdoc_options += RDOC_OPTS + 
+    ["--exclude", "^(examples|extras)\/", "--exclude", "lib/assistance.rb"]
+  s.summary = "Database access for Ruby"
+  s.description = s.summary
+  s.author = "Ezra Zygmuntowicz, Sam Smoot, Sharon Rosner"
+  s.email = "ezmobius@gmail.com, ssmoot@gmail.com, ciconia@gmail.com"
+  s.homepage = "http://assistance.rubyforge.org"
+  s.required_ruby_version = ">= 1.8.4"
+
+  s.files = %w(COPYING README Rakefile) + Dir.glob("{doc,spec,lib}/**/*")
+
+  s.require_path = "lib"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.need_tar = true
+  p.gem_spec = spec
+end
+
+##############################################################################
+# installation & removal
+##############################################################################
+task :install do
+  sh %{rake package}
+  sh %{sudo gem install pkg/#{NAME}-#{VERS}}
+end
+
+task :install_no_docs do
+  sh %{rake package}
+  sh %{sudo gem install pkg/#{NAME}-#{VERS} --no-rdoc --no-ri}
+end
+
+task :uninstall => [:clean] do
+  sh %{sudo gem uninstall #{NAME}}
+end
+
+task :tag do
+  cwd = FileUtils.pwd
+  sh %{cd ../.. && svn copy #{cwd} tags/#{NAME}-#{VERS} && svn commit -m "#{NAME}-#{VERS} tag." tags}
+end
+
+##############################################################################
+# gem and rdoc release
+##############################################################################
+task :release => [:package] do
+  sh %{rubyforge login}
+  sh %{rubyforge add_release #{NAME} #{NAME} #{VERS} pkg/#{NAME}-#{VERS}.tgz}
+  sh %{rubyforge add_file #{NAME} #{NAME} #{VERS} pkg/#{NAME}-#{VERS}.gem}
+end
+
+##############################################################################
+# specs
+##############################################################################
+require "spec/rake/spectask"
+
+desc "Run specs with coverage"
+Spec::Rake::SpecTask.new("spec") do |t|
+  t.spec_files = FileList["spec/*_spec.rb"]
+  t.spec_opts  = File.read("spec/spec.opts").split("\n")
+  t.rcov_opts  = File.read("spec/rcov.opts").split("\n")
+  t.rcov = true
+end
+
+desc "Run specs without coverage"
+Spec::Rake::SpecTask.new("spec_no_cov") do |t|
+  t.spec_files = FileList["spec/*_spec.rb"]
+  t.spec_opts  = File.read("spec/spec.opts").split("\n")
+end
+

data/lib/assistance.rb

@@ -0,0 +1,8 @@
+dir = File.join(File.dirname(__FILE__), "assistance")
+%w[
+  core_ext
+  time_calculations
+  connection_pool
+  inflector
+  blank
+].each {|f| require(File.join(dir, f))}

data/lib/assistance/blank.rb

@@ -0,0 +1,35 @@
+class Object
+  def blank?
+    nil? || (respond_to?(:empty?) && empty?)
+  end
+end
+
+class Numeric
+  def blank?
+    false
+  end
+end
+
+class NilClass
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  def blank?
+    false
+  end
+end
+
+class FalseClass
+  def blank?
+    true
+  end
+end
+
+class String
+  def blank?
+    empty? || self =~ /\A\s*\Z/
+  end
+end

data/lib/assistance/connection_pool.rb

@@ -0,0 +1,152 @@
+require 'thread'
+
+module Sequel
+  # A ConnectionPool manages access to database connections by keeping
+  # multiple connections and giving threads exclusive access to each
+  # connection.
+  class ConnectionPool
+    attr_reader :mutex
+    
+    # The maximum number of connections.
+    attr_reader :max_size
+    
+    # The proc used to create a new connection.
+    attr_accessor :connection_proc
+    
+    attr_reader :available_connections, :allocated, :created_count
+  
+    # Constructs a new pool with a maximum size. If a block is supplied, it
+    # is used to create new connections as they are needed.
+    #
+    #   pool = ConnectionPool.new(10) {MyConnection.new(opts)}
+    #
+    # The connection creation proc can be changed at any time by assigning a 
+    # Proc to pool#connection_proc.
+    #
+    #   pool = ConnectionPool.new(10)
+    #   pool.connection_proc = proc {MyConnection.new(opts)}
+    def initialize(max_size = 4, &block)
+      @max_size = max_size
+      @mutex = Mutex.new
+      @connection_proc = block
+
+      @available_connections = []
+      @allocated = {}
+      @created_count = 0
+    end
+    
+    # Returns the number of created connections.
+    def size
+      @created_count
+    end
+    
+    # Assigns a connection to the current thread, yielding the connection
+    # to the supplied block.
+    # 
+    #   pool.hold {|conn| conn.execute('DROP TABLE posts')}
+    # 
+    # Pool#hold is re-entrant, meaning it can be called recursively in
+    # the same thread without blocking.
+    #
+    # If no connection is available, Pool#hold will block until a connection
+    # is available.
+    def hold
+      t = Thread.current
+      if (conn = owned_connection(t))
+        return yield(conn)
+      end
+      while !(conn = acquire(t))
+        sleep 0.001
+      end
+      begin
+        yield conn
+      ensure
+        release(t)
+      end
+    rescue Exception => e
+      # if the error is not a StandardError it is converted into RuntimeError.
+      raise e.is_a?(StandardError) ? e : e.message
+    end
+    
+    # Removes all connection currently available, optionally yielding each 
+    # connection to the given block. This method has the effect of 
+    # disconnecting from the database. Once a connection is requested using
+    # #hold, the connection pool creates new connections to the database.
+    def disconnect(&block)
+      @mutex.synchronize do
+        @available_connections.each {|c| block[c]} if block
+        @available_connections = []
+        @created_count = @allocated.size
+      end
+    end
+    
+    private
+      # Returns the connection owned by the supplied thread, if any.
+      def owned_connection(thread)
+        @mutex.synchronize {@allocated[thread]}
+      end
+      
+      # Assigns a connection to the supplied thread, if one is available.
+      def acquire(thread)
+        @mutex.synchronize do
+          if conn = available
+            @allocated[thread] = conn
+          end
+        end
+      end
+      
+      # Returns an available connection. If no connection is available,
+      # tries to create a new connection.
+      def available
+        @available_connections.pop || make_new
+      end
+      
+      # Creates a new connection if the size of the pool is less than the
+      # maximum size.
+      def make_new
+        if @created_count < @max_size
+          @created_count += 1
+          @connection_proc ? @connection_proc.call : \
+            (raise Error, "No connection proc specified")
+        end
+      end
+      
+      # Releases the connection assigned to the supplied thread.
+      def release(thread)
+        @mutex.synchronize do
+          @available_connections << @allocated[thread]
+          @allocated.delete(thread)
+        end
+      end
+  end
+
+  # A SingleThreadedPool acts as a replacement for a ConnectionPool for use
+  # in single-threaded applications. ConnectionPool imposes a substantial
+  # performance penalty, so SingleThreadedPool is used to gain some speed.
+  class SingleThreadedPool
+    attr_reader :conn
+    attr_writer :connection_proc
+    
+    # Initializes the instance with the supplied block as the connection_proc.
+    def initialize(&block)
+      @connection_proc = block
+    end
+    
+    # Yields the connection to the supplied block. This method simulates the
+    # ConnectionPool#hold API.
+    def hold
+      @conn ||= @connection_proc.call
+      yield @conn
+    rescue Exception => e
+      # if the error is not a StandardError it is converted into RuntimeError.
+      raise e.is_a?(StandardError) ? e : e.message
+    end
+    
+    # Disconnects from the database. Once a connection is requested using
+    # #hold, the connection is reestablished.
+    def disconnect(&block)
+      block[@conn] if block && @conn
+      @conn = nil
+    end
+  end
+end

data/lib/assistance/inflections.rb

@@ -0,0 +1,112 @@
+Inflector.inflections do |inflect|
+  inflect.plural(/$/, 's')
+  inflect.plural(/s$/i, 's')
+  inflect.plural(/(ax|test)is$/i, '\1es')
+  inflect.plural(/(octop|vir)us$/i, '\1i')
+  inflect.plural(/(alias|status)$/i, '\1es')
+  inflect.plural(/(bu)s$/i, '\1ses')
+  inflect.plural(/(buffal|tomat)o$/i, '\1oes')
+  inflect.plural(/([ti])um$/i, '\1a')
+  inflect.plural(/sis$/i, 'ses')
+  inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+  inflect.plural(/(hive)$/i, '\1s')
+  inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+  inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+  inflect.plural(/(matr|vert|ind)ix|ex$/i, '\1ices')
+  inflect.plural(/([m|l])ouse$/i, '\1ice')
+  inflect.plural(/^(ox)$/i, '\1en')
+  inflect.plural(/(quiz)$/i, '\1zes')
+
+  inflect.singular(/s$/i, '')
+  inflect.singular(/(n)ews$/i, '\1ews')
+  inflect.singular(/([ti])a$/i, '\1um')
+  inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
+  inflect.singular(/(^analy)ses$/i, '\1sis')
+  inflect.singular(/([^f])ves$/i, '\1fe')
+  inflect.singular(/(hive)s$/i, '\1')
+  inflect.singular(/(tive)s$/i, '\1')
+  inflect.singular(/([lr])ves$/i, '\1f')
+  inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+  inflect.singular(/(s)eries$/i, '\1eries')
+  inflect.singular(/(m)ovies$/i, '\1ovie')
+  inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
+  inflect.singular(/([m|l])ice$/i, '\1ouse')
+  inflect.singular(/(bus)es$/i, '\1')
+  inflect.singular(/(o)es$/i, '\1')
+  inflect.singular(/(shoe)s$/i, '\1')
+  inflect.singular(/(cris|ax|test)es$/i, '\1is')
+  inflect.singular(/(octop|vir)i$/i, '\1us')
+  inflect.singular(/(alias|status)es$/i, '\1')
+  inflect.singular(/^(ox)en/i, '\1')
+  inflect.singular(/(vert|ind)ices$/i, '\1ex')
+  inflect.singular(/(matr)ices$/i, '\1ix')
+  inflect.singular(/(quiz)zes$/i, '\1')
+
+  inflect.irregular('person', 'people')
+  inflect.irregular('man', 'men')
+  inflect.irregular('child', 'children')
+  inflect.irregular('sex', 'sexes')
+  inflect.irregular('move', 'moves')
+
+  inflect.uncountable(%w(equipment information rice money species series fish sheep))
+end
+
+module Inflections #:nodoc:
+
+  def pluralize
+    Inflector.pluralize(self)
+  end
+
+  def singularize
+    Inflector.singularize(self)
+  end
+
+  def camelize(first_letter = :upper)
+    case first_letter
+      when :upper then Inflector.camelize(self, true)
+      when :lower then Inflector.camelize(self, false)
+    end
+  end
+  alias_method :camelcase, :camelize
+
+  def titleize
+    Inflector.titleize(self)
+  end
+  alias_method :titlecase, :titleize
+
+  def underscore
+    Inflector.underscore(self)
+  end
+
+  def dasherize
+    Inflector.dasherize(self)
+  end
+
+  def demodulize
+    Inflector.demodulize(self)
+  end
+
+  def tableize
+    Inflector.tableize(self)
+  end
+
+  def classify
+    Inflector.classify(self)
+  end
+
+  def humanize
+    Inflector.humanize(self)
+  end
+
+  def foreign_key(separate_class_name_and_id_with_underscore = true)
+    Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
+  end
+
+  def constantize
+    Inflector.constantize(self)
+  end
+end
+
+class String
+  include Inflections
+end

data/lib/assistance/inflector.rb

@@ -0,0 +1,275 @@
+require 'singleton'
+
+# The Inflector transforms words from singular to plural, class names to table names, modularized class names to ones without,
+# and class names to foreign keys. The default inflections for pluralization, singularization, and uncountable words are kept
+# in inflections.rb.
+module Inflector
+  # A singleton instance of this class is yielded by Inflector.inflections, which can then be used to specify additional
+  # inflection rules. Examples:
+  #
+  #   Inflector.inflections do |inflect|
+  #     inflect.plural /^(ox)$/i, '\1\2en'
+  #     inflect.singular /^(ox)en/i, '\1'
+  #
+  #     inflect.irregular 'octopus', 'octopi'
+  #
+  #     inflect.uncountable "equipment"
+  #   end
+  #
+  # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
+  # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
+  # already have been loaded.
+  class Inflections
+    include Singleton
+
+    attr_reader :plurals, :singulars, :uncountables
+
+    def initialize
+      @plurals, @singulars, @uncountables = [], [], []
+    end
+
+    # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    def plural(rule, replacement)
+      @plurals.insert(0, [rule, replacement])
+    end
+
+    # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    def singular(rule, replacement)
+      @singulars.insert(0, [rule, replacement])
+    end
+
+    # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
+    # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
+    #
+    # Examples:
+    #   irregular 'octopus', 'octopi'
+    #   irregular 'person', 'people'
+    def irregular(singular, plural)
+      plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
+      singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+    end
+
+    # Add uncountable words that shouldn't be attempted inflected.
+    #
+    # Examples:
+    #   uncountable "money"
+    #   uncountable "money", "information"
+    #   uncountable %w( money information rice )
+    def uncountable(*words)
+      (@uncountables << words).flatten!
+    end
+
+    # Clears the loaded inflections within a given scope (default is :all). Give the scope as a symbol of the inflection type,
+    # the options are: :plurals, :singulars, :uncountables
+    #
+    # Examples:
+    #   clear :all
+    #   clear :plurals
+    def clear(scope = :all)
+      case scope
+        when :all
+          @plurals, @singulars, @uncountables = [], [], []
+        else
+          instance_variable_set "@#{scope}", []
+      end
+    end
+  end
+
+  extend self
+
+  def inflections
+    if block_given?
+      yield Inflections.instance
+    else
+      Inflections.instance
+    end
+  end
+
+  # Returns the plural form of the word in the string.
+  #
+  # Examples
+  #   "post".pluralize #=> "posts"
+  #   "octopus".pluralize #=> "octopi"
+  #   "sheep".pluralize #=> "sheep"
+  #   "words".pluralize #=> "words"
+  #   "the blue mailman".pluralize #=> "the blue mailmen"
+  #   "CamelOctopus".pluralize #=> "CamelOctopi"
+  def pluralize(word)
+    result = word.to_s.dup
+
+    if inflections.uncountables.include?(result.downcase)
+      result
+    else
+      inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+      result
+    end
+  end
+
+  # The reverse of pluralize, returns the singular form of a word in a string.
+  #
+  # Examples
+  #   "posts".singularize #=> "post"
+  #   "octopi".singularize #=> "octopus"
+  #   "sheep".singluarize #=> "sheep"
+  #   "word".singluarize #=> "word"
+  #   "the blue mailmen".singularize #=> "the blue mailman"
+  #   "CamelOctopi".singularize #=> "CamelOctopus"
+  def singularize(word)
+    result = word.to_s.dup
+
+    if inflections.uncountables.include?(result.downcase)
+      result
+    else
+      inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+      result
+    end
+  end
+
+  # By default, camelize converts strings to UpperCamelCase. If the argument to camelize
+  # is set to ":lower" then camelize produces lowerCamelCase.
+  #
+  # camelize will also convert '/' to '::' which is useful for converting paths to namespaces
+  #
+  # Examples
+  #   "active_record".camelize #=> "ActiveRecord"
+  #   "active_record".camelize(:lower) #=> "activeRecord"
+  #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
+  #   "active_record/errors".camelize(:lower) #=> "activeRecord::Errors"
+  def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    else
+      lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
+    end
+  end
+
+  # Capitalizes all the words and replaces some characters in the string to create
+  # a nicer looking title. Titleize is meant for creating pretty output. It is not
+  # used in the Rails internals.
+  #
+  # titleize is also aliased as as titlecase
+  #
+  # Examples
+  #   "man from the boondocks".titleize #=> "Man From The Boondocks"
+  #   "x-men: the last stand".titleize #=> "X Men: The Last Stand"
+  def titleize(word)
+    humanize(underscore(word)).gsub(/\b([a-z])/) { $1.capitalize }
+  end
+
+  # The reverse of +camelize+. Makes an underscored form from the expression in the string.
+  #
+  # Changes '::' to '/' to convert namespaces to paths.
+  #
+  # Examples
+  #   "ActiveRecord".underscore #=> "active_record"
+  #   "ActiveRecord::Errors".underscore #=> active_record/errors
+  def underscore(camel_cased_word)
+    camel_cased_word.to_s.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+
+  # Replaces underscores with dashes in the string.
+  #
+  # Example
+  #   "puni_puni" #=> "puni-puni"
+  def dasherize(underscored_word)
+    underscored_word.gsub(/_/, '-')
+  end
+
+  # Capitalizes the first word and turns underscores into spaces and strips _id.
+  # Like titleize, this is meant for creating pretty output.
+  #
+  # Examples
+  #   "employee_salary" #=> "Employee salary"
+  #   "author_id" #=> "Author"
+  def humanize(lower_case_and_underscored_word)
+    lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+  end
+
+  # Removes the module part from the expression in the string
+  #
+  # Examples
+  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
+  #   "Inflections".demodulize #=> "Inflections"
+  def demodulize(class_name_in_module)
+    class_name_in_module.to_s.gsub(/^.*::/, '')
+  end
+
+  # Create the name of a table like Rails does for models to table names. This method
+  # uses the pluralize method on the last word in the string.
+  #
+  # Examples
+  #   "RawScaledScorer".tableize #=> "raw_scaled_scorers"
+  #   "egg_and_ham".tableize #=> "egg_and_hams"
+  #   "fancyCategory".tableize #=> "fancy_categories"
+  def tableize(class_name)
+    pluralize(underscore(class_name))
+  end
+
+  # Create a class name from a table name like Rails does for table names to models.
+  # Note that this returns a string and not a Class. (To convert to an actual class
+  # follow classify with constantize.)
+  #
+  # Examples
+  #   "egg_and_hams".classify #=> "EggAndHam"
+  #   "post".classify #=> "Post"
+  def classify(table_name)
+    # strip out any leading schema name
+    camelize(singularize(table_name.to_s.sub(/.*\./, '')))
+  end
+
+  # Creates a foreign key name from a class name.
+  # +separate_class_name_and_id_with_underscore+ sets whether
+  # the method should put '_' between the name and 'id'.
+  #
+  # Examples
+  #   "Message".foreign_key #=> "message_id"
+  #   "Message".foreign_key(false) #=> "messageid"
+  #   "Admin::Post".foreign_key #=> "post_id"
+  def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
+    underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id")
+  end
+
+  # Constantize tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.
+  #
+  # Examples
+  #   "Module".constantize #=> Module
+  #   "Class".constantize #=> Class
+  def constantize(camel_cased_word)
+    unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+      raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+    end
+
+    Object.module_eval("::#{$1}", __FILE__, __LINE__)
+  end
+
+  # Ordinalize turns a number into an ordinal string used to denote the
+  # position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+  #
+  # Examples
+  #   ordinalize(1)     # => "1st"
+  #   ordinalize(2)     # => "2nd"
+  #   ordinalize(1002)  # => "1002nd"
+  #   ordinalize(1003)  # => "1003rd"
+  def ordinalize(number)
+    if (11..13).include?(number.to_i % 100)
+      "#{number}th"
+    else
+      case number.to_i % 10
+        when 1: "#{number}st"
+        when 2: "#{number}nd"
+        when 3: "#{number}rd"
+        else    "#{number}th"
+      end
+    end
+  end
+end
+
+require File.dirname(__FILE__) + '/inflections'

data/lib/assistance/time_calculations.rb

@@ -0,0 +1,35 @@
+# Facilitates time calculations by providing methods to convert from larger
+# time units to seconds, and to convert relative time intervals to absolute
+# ones. This module duplicates some of the functionality provided by Rails'
+# ActiveSupport::CoreExtensions::Numeric::Time module.
+
+module Assistance
+  module TimeCalculations
+    MINUTE = 60
+    HOUR = 3600
+    DAY = 86400
+    WEEK = DAY * 7
+
+    # Converts self from minutes to seconds
+    def minutes;  self * MINUTE;  end; alias_method :minute, :minutes
+    # Converts self from hours to seconds
+    def hours;    self * HOUR;    end; alias_method :hour, :hours
+    # Converts self from days to seconds
+    def days;     self * DAY;     end; alias_method :day, :days
+    # Converts self from weeks to seconds
+    def weeks;    self * WEEK;    end; alias_method :week, :weeks
+
+    # Returns the time at now - self.
+    def ago(t = Time.now); t - self; end
+    alias_method :before, :ago
+
+    # Returns the time at now + self.
+    def from_now(t = Time.now); t + self; end
+    alias_method :since, :from_now
+  end
+end
+
+# numeric extensions
+class Numeric
+  include Assistance::TimeCalculations
+end

data/spec/blank_spec.rb

@@ -0,0 +1,8 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "blank?" do
+  it "should mark empty objects as blank" do
+    [ nil, false, '', '   ', "  \n\t  \r ", [], {} ].each { |f| f.should be_blank }
+    [ Object.new, true, 0, 1, 'a', [nil], { nil => 0 } ].each { |t| t.should_not be_blank }
+  end
+end

data/spec/connection_pool_spec.rb

@@ -0,0 +1,358 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "An empty ConnectionPool" do
+  setup do
+    @cpool = Sequel::ConnectionPool.new
+  end
+
+  specify "should have no available connections" do
+    @cpool.available_connections.should == []
+  end
+
+  specify "should have no allocated connections" do
+    @cpool.allocated.should == {}
+  end
+
+  specify "should have a created_count of zero" do
+    @cpool.created_count.should == 0
+  end
+end
+
+context "A connection pool handling connections" do
+  setup do
+    @max_size = 2
+    @cpool = Sequel::ConnectionPool.new(@max_size) {:got_connection}
+  end
+
+  specify "#hold should increment #created_count" do
+    @cpool.hold do
+      @cpool.created_count.should == 1
+      @cpool.hold {@cpool.created_count.should == 1}
+    end
+  end
+
+  specify "#hold should add the connection to the #allocated hash" do
+    @cpool.hold do
+      @cpool.allocated.size.should == 1
+  
+      @cpool.allocated.values.should == [:got_connection]
+    end
+  end
+
+  specify "#hold should yield a new connection" do
+    @cpool.hold {|conn| conn.should == :got_connection}
+  end
+
+  specify "a connection should be de-allocated after it has been used in #hold" do
+    @cpool.hold {}
+    @cpool.allocated.size.should == 0
+  end
+
+  specify "#hold should return the value of its block" do
+    @cpool.hold {:block_return}.should == :block_return
+  end
+
+  specify "#make_new should not make more than max_size connections" do
+    @cpool.send(:make_new).should == :got_connection
+    @cpool.send(:make_new).should == :got_connection
+    @cpool.send(:make_new).should == nil
+    @cpool.created_count.should == 2
+  end
+end
+
+class DummyConnection
+  @@value = 0
+  def initialize
+    @@value += 1
+  end
+  
+  def value
+    @@value
+  end
+end
+
+context "ConnectionPool#hold" do
+  setup do
+    @pool = Sequel::ConnectionPool.new {DummyConnection.new}
+  end
+  
+  specify "should pass the result of the connection maker proc to the supplied block" do
+    res = nil
+    @pool.hold {|c| res = c}
+    res.should be_a_kind_of(DummyConnection)
+    res.value.should == 1
+    @pool.hold {|c| res = c}
+    res.should be_a_kind_of(DummyConnection)
+    res.value.should == 1 # the connection maker is invoked only once
+  end
+  
+  specify "should be re-entrant by the same thread" do
+    cc = nil
+    @pool.hold {|c| @pool.hold {|c| @pool.hold {|c| cc = c}}}
+    cc.should be_a_kind_of(DummyConnection)
+  end
+  
+  specify "should catch exceptions and reraise them" do
+    proc {@pool.hold {|c| c.foobar}}.should raise_error(NoMethodError)
+  end
+  
+  specify "should handle Exception errors (normally not caught by rescue)" do
+    err = nil
+    begin
+      @pool.hold {raise Exception}
+    rescue => e
+      err = e
+    end
+    err.should be_a_kind_of(RuntimeError)
+  end
+end
+
+context "ConnectionPool#connection_proc" do
+  setup do
+    @pool = Sequel::ConnectionPool.new
+  end
+  
+  specify "should be nil if no block is supplied to the pool" do
+    @pool.connection_proc.should be_nil
+    proc {@pool.hold {}}.should raise_error
+  end
+  
+  specify "should be mutable" do
+    @pool.connection_proc = proc {'herro'}
+    res = nil
+    proc {@pool.hold {|c| res = c}}.should_not raise_error
+    res.should == 'herro'
+  end
+end
+
+context "A connection pool with a max size of 1" do
+  setup do
+    @invoked_count = 0
+    @pool = Sequel::ConnectionPool.new(1) {@invoked_count += 1; 'herro'}
+  end
+  
+  specify "should let only one thread access the connection at any time" do
+    cc,c1, c2 = nil
+    
+    t1 = Thread.new {@pool.hold {|c| cc = c; c1 = c.dup; while c == 'herro';sleep 0.1;end}}
+    sleep 0.2
+    cc.should == 'herro'
+    c1.should == 'herro'
+    
+    t2 = Thread.new {@pool.hold {|c| c2 = c.dup; while c == 'hello';sleep 0.1;end}}
+    sleep 0.2
+    
+    # connection held by t1
+    t1.should be_alive
+    t2.should be_alive
+    
+    cc.should == 'herro'
+    c1.should == 'herro'
+    c2.should be_nil
+    
+    @pool.available_connections.should be_empty
+    @pool.allocated.should == {t1 => cc}
+    
+    cc.gsub!('rr', 'll')
+    sleep 0.5
+    
+    # connection held by t2
+    t1.should_not be_alive
+    t2.should be_alive
+
+    c2.should == 'hello'
+
+    @pool.available_connections.should be_empty
+    @pool.allocated.should == {t2 => cc}
+    
+    cc.gsub!('ll', 'rr')
+    sleep 0.5
+    
+    #connection released
+    t2.should_not be_alive
+    
+    cc.should == 'herro'
+    
+    @invoked_count.should == 1
+    @pool.size.should == 1
+    @pool.available_connections.should == [cc]
+    @pool.allocated.should be_empty
+  end
+  
+  specify "should let the same thread reenter #hold" do
+    c1, c2, c3 = nil
+    @pool.hold do |c|
+      c1 = c
+      @pool.hold do |c|
+        c2 = c
+        @pool.hold do |c|
+          c3 = c
+        end
+      end
+    end
+    c1.should == 'herro'
+    c2.should == 'herro'
+    c3.should == 'herro'
+    
+    @invoked_count.should == 1
+    @pool.size.should == 1
+    @pool.available_connections.size.should == 1
+    @pool.allocated.should be_empty
+  end
+end
+
+context "A connection pool with a max size of 5" do
+  setup do
+    @invoked_count = 0
+    @pool = Sequel::ConnectionPool.new(5) {@invoked_count += 1}
+  end
+  
+  specify "should let five threads simultaneously access separate connections" do
+    cc = {}
+    threads = []
+    stop = nil
+    
+    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.1;end}}; sleep 0.1}
+    sleep 0.2
+    threads.each {|t| t.should be_alive}
+    cc.size.should == 5
+    @invoked_count.should == 5
+    @pool.size.should == 5
+    @pool.available_connections.should be_empty
+    @pool.allocated.should == {threads[0] => 1, threads[1] => 2, threads[2] => 3,
+      threads[3] => 4, threads[4] => 5}
+    
+    threads[0].raise "your'e dead"
+    sleep 0.1
+    threads[3].raise "your'e dead too"
+    
+    sleep 0.1
+    
+    @pool.available_connections.should == [1, 4]
+    @pool.allocated.should == {threads[1] => 2, threads[2] => 3, threads[4] => 5}
+    
+    stop = true
+    sleep 0.2
+    
+    @pool.available_connections.size.should == 5
+    @pool.allocated.should be_empty
+  end
+  
+  specify "should block threads until a connection becomes available" do
+    cc = {}
+    threads = []
+    stop = nil
+    
+    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.1;end}}; sleep 0.1}
+    sleep 0.2
+    threads.each {|t| t.should be_alive}
+    @pool.available_connections.should be_empty
+
+    3.times {|i| threads << Thread.new {@pool.hold {|c| cc[i + 5] = c}}}
+    
+    sleep 0.2
+    threads[5].should be_alive
+    threads[6].should be_alive
+    threads[7].should be_alive
+    cc.size.should == 5
+    cc[5].should be_nil
+    cc[6].should be_nil
+    cc[7].should be_nil
+    
+    stop = true
+    sleep 0.3
+    
+    threads.each {|t| t.should_not be_alive}
+    
+    @pool.size.should == 5
+    @invoked_count.should == 5
+    @pool.available_connections.size.should == 5
+    @pool.allocated.should be_empty
+  end
+end
+
+context "ConnectionPool#disconnect" do
+  setup do
+    @count = 0
+    @pool = Sequel::ConnectionPool.new(5) {{:id => @count += 1}}
+  end
+  
+  specify "should invoke the given block for each available connection" do
+    threads = []
+    stop = nil
+    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
+    while @pool.size < 5
+      sleep 0.2
+    end
+    stop = true
+    sleep 1
+    threads.each {|t| t.join}
+    
+    @pool.size.should == 5
+    @pool.available_connections.size.should == 5
+    @pool.available_connections.each {|c| c[:id].should_not be_nil}
+    conns = []
+    @pool.disconnect {|c| conns << c}
+    conns.size.should == 5
+  end
+  
+  specify "should remove all available connections" do
+    threads = []
+    stop = nil
+    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
+    while @pool.size < 5
+      sleep 0.2
+    end
+    stop = true
+    sleep 1
+    threads.each {|t| t.join}
+    
+    @pool.size.should == 5
+    @pool.disconnect
+    @pool.size.should == 0
+  end
+
+  specify "should not touch connections in use" do
+    threads = []
+    stop = nil
+    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
+    while @pool.size < 5
+      sleep 0.2
+    end
+    stop = true
+    sleep 1
+    threads.each {|t| t.join}
+    
+    @pool.size.should == 5
+    
+    @pool.hold do |conn|
+      @pool.available_connections.size.should == 4
+      @pool.available_connections.each {|c| c.should_not be(conn)}
+      conns = []
+      @pool.disconnect {|c| conns << c}
+      conns.size.should == 4
+    end
+    @pool.size.should == 1
+  end
+end
+
+context "SingleThreadedPool" do
+  setup do
+    @pool = Sequel::SingleThreadedPool.new {1234}
+  end
+  
+  specify "should provide a #hold method" do
+    conn = nil
+    @pool.hold {|c| conn = c}
+    conn.should == 1234
+  end
+  
+  specify "should provide a #disconnect method" do
+    @pool.hold {|c|}
+    @pool.conn.should == 1234
+    conn = nil
+    @pool.disconnect {|c| conn = c}
+    conn.should == 1234
+    @pool.conn.should be_nil
+  end
+end

data/spec/inflector_spec.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Inflector do
+  it "should transform words from singular to plural" do
+    "post".pluralize.should == "posts"
+    "octopus".pluralize.should =="octopi"
+    "the blue mailman".pluralize.should == "the blue mailmen"
+    "CamelOctopus".pluralize.should == "CamelOctopi"
+  end
+  
+  it "should transform words from plural to singular" do
+    "posts".singularize.should == "post"
+    "octopi".singularize.should == "octopus"
+    "the blue mailmen".singularize.should == "the blue mailman"
+    "CamelOctopi".singularize.should == "CamelOctopus"
+  end
+  
+  it "should transform class names to table names" do
+    "RawScaledScorer".tableize.should == "raw_scaled_scorers"
+    "egg_and_ham".tableize.should == "egg_and_hams"
+    "fancyCategory".tableize.should == "fancy_categories"
+  end
+  
+  it "should tranform table names to class names" do
+    "egg_and_hams".classify.should == "EggAndHam"
+    "post".classify.should == "Post"
+  end
+  
+  it "should create a foreign key name from a class name" do
+    "Message".foreign_key.should == "message_id"
+    "Message".foreign_key(false).should == "messageid"
+    "Admin::Post".foreign_key.should == "post_id"
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,4 @@
+--exclude
+gems
+--exclude
+spec

data/spec/spec.opts

@@ -0,0 +1,5 @@
+--colour
+--backtrace
+--format
+specdoc
+--diff

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "../lib/assistance") 

data/spec/time_calculations_spec.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "Time calculations" do
+  specify "should support conversion of minutes to seconds" do
+    1.minute.should == 60
+    3.minutes.should == 180
+  end
+  
+  specify "should support conversion of hours to seconds" do
+    1.hour.should == 3600
+    3.hours.should == 3600 * 3
+  end
+
+  specify "should support conversion of days to seconds" do
+    1.day.should == 86400
+    3.days.should == 86400 * 3
+  end
+
+  specify "should support conversion of weeks to seconds" do
+    1.week.should == 86400 * 7
+    3.weeks.should == 86400 * 7 * 3
+  end
+  
+  specify "should provide #ago functionality" do
+    t1 = Time.now
+    t2 = 1.day.ago
+    t1.should > t2
+    ((t1 - t2).to_i - 86400).abs.should < 2
+    
+    t1 = Time.now
+    t2 = 1.day.before(t1)
+    t2.should == t1 - 1.day
+  end
+
+  specify "should provide #from_now functionality" do
+    t1 = Time.now
+    t2 = 1.day.from_now
+    t1.should < t2
+    ((t2 - t1).to_i - 86400).abs.should < 2
+    
+    t1 = Time.now
+    t2 = 1.day.since(t1)
+    t2.should == t1 + 1.day
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: assistance
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ezra Zygmuntowicz, Sam Smoot, Sharon Rosner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-01-10 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Database access for Ruby
+email: ezmobius@gmail.com, ssmoot@gmail.com, ciconia@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGELOG
+- COPYING
+files: 
+- COPYING
+- README
+- Rakefile
+- spec/blank_spec.rb
+- spec/connection_pool_spec.rb
+- spec/inflector_spec.rb
+- spec/rcov.opts
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/time_calculations_spec.rb
+- lib/assistance
+- lib/assistance/blank.rb
+- lib/assistance/connection_pool.rb
+- lib/assistance/core_ext.rb
+- lib/assistance/inflections.rb
+- lib/assistance/inflector.rb
+- lib/assistance/time_calculations.rb
+- lib/assistance.rb
+- CHANGELOG
+has_rdoc: true
+homepage: http://assistance.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --quiet
+- --title
+- "Assistance: light-weight application support"
+- --opname
+- index.html
+- --line-numbers
+- --main
+- README
+- --inline-source
+- --exclude
+- ^(examples|extras)/
+- --exclude
+- lib/assistance.rb
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.4
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: assistance
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Database access for Ruby
+test_files: []
+