deathsyn-seedling 0.0.1

data/AUTHORS

@@ -0,0 +1,3 @@
+Following persons have contributed to seedling.
+(Sorted by number of submitted patches, then alphabetically)
+

data/CHANGELOG

@@ -0,0 +1,72 @@
+[27deb65 | Thu May 14 15:30:14 UTC 2009] Kevin Berry <kevin@opensourcealchemist.com>
+
+  * Version 0.0.1
+
+[4017044 | Thu May 14 14:50:26 UTC 2009] Kevin Berry <kevinberry@nrs.us>
+
+  * Remove old library dir, and correct erb output for library.rb.seed
+
+[04d16e0 | Thu May 14 14:45:02 UTC 2009] Kevin Berry <kevinberry@nrs.us>
+
+  * Get the library module and children in the right place.  TODO: Remove library directory from plant.
+
+[25e0453 | Thu May 14 14:09:29 UTC 2009] Kevin Berry <kevinberry@nrs.us>
+
+  * Fix erb calls (Railsism doesn't work!)
+
+[f8eeba5 | Wed May 13 18:55:39 UTC 2009] Kevin Berry <kevinberry@nrs.us>
+
+  * Add params for doc_generator, test_suite, correct email parameter.
+
+[ead7fbf | Wed May 13 18:22:26 UTC 2009] Kevin Berry <kevinberry@nrs.us>
+
+  * Add rubyforge_project commandline option.
+
+[fb7663b | Wed May 13 17:34:18 UTC 2009] Kevin Berry <kevinberry@nrs.us>
+
+  * Fix a couple of templates, and add more planting options.
+
+[eb1d0d0 | Wed May 13 15:40:01 UTC 2009] Kevin Berry <kevinberry@nrs.us>
+
+  * Convert setup into a seed (erb) so that bacon/rspec and rdoc/yard choices can be made.
+
+[771f9d3 | Tue May 12 23:12:42 UTC 2009] Kevin Berry <KevinBerry@nrs.us>
+
+  * rest of erb to seed conversion.
+
+[72aa1b4 | Tue May 12 23:06:40 UTC 2009] Kevin Berry <KevinBerry@nrs.us>
+
+  * Adjust library.rb.erb to library.rb.seed, and adjust template data to match new standards.
+
+[2f71f19 | Tue May 12 22:50:37 UTC 2009] TJ Vanderpoel <bougy.man@gmail.com>
+
+  * changed extension for templates to be parsed with erb to .seed to remove conflicts with actual .erb files.  added most options to Rakefile.seed.  TODO: finish out Rakefile.seed and move on to more .seed files where dynamic values are needed
+
+[aff3223 | Mon May 11 19:41:52 UTC 2009] TJ Vanderpoel <bougyman@zero.(none)>
+
+  * added bin/seedling and began forming bin.rb to seedling usage
+
+[6765184 | Sun May 10 22:32:16 UTC 2009] Kevin Berry <Kevin Berry>
+
+  * Modify Rakefile.erb to get some project info, need to get ProjectCreator to feed the right info.
+
+[5917d53 | Sun May 10 03:42:26 UTC 2009] Kevin Berry <Kevin Berry>
+
+  * Make plant work.
+
+[f02eaf1 | Sun May 10 03:06:22 UTC 2009] Kevin Berry <Kevin Berry>
+
+  * Bring in initial generator and ProjectCreator kit (stripped down bougyman's autumn library.)
+
+[22fb2a5 | Fri May 08 03:19:21 UTC 2009] TJ Vanderpoel <bougy.man@gmail.com>
+
+  * changed env variable for versioning to VERSION
+
+[6329710 | Fri May 08 03:07:50 UTC 2009] TJ Vanderpoel <bougy.man@gmail.com>
+
+  * added yard task and a README, plus a .gitignore
+
+[41fd3c5 | Thu May 07 19:21:22 UTC 2009] TJ Vanderpoel <bougy.man@gmail.com>
+
+  * new tree to begin seedling work
+

data/MANIFEST

@@ -0,0 +1,42 @@
+AUTHORS
+CHANGELOG
+MANIFEST
+README
+Rakefile
+bin/seedling
+lib/seedling.rb
+lib/seedling/bin.rb
+lib/seedling/extensions/inflector.rb
+lib/seedling/project_creator.rb
+lib/seedling/version.rb
+lib/templates/core/Rakefile.seed
+lib/templates/core/lib/library.rb.seed
+lib/templates/core/lib/library/version.rb.seed
+lib/templates/core/spec/helper.rb.seed
+lib/templates/core/tasks/authors.rake
+lib/templates/core/tasks/bacon.rake
+lib/templates/core/tasks/changelog.rake
+lib/templates/core/tasks/copyright.rake
+lib/templates/core/tasks/gem.rake
+lib/templates/core/tasks/gem_installer.rake
+lib/templates/core/tasks/install_dependencies.rake
+lib/templates/core/tasks/manifest.rake
+lib/templates/core/tasks/rcov.rake
+lib/templates/core/tasks/release.rake
+lib/templates/core/tasks/reversion.rake
+lib/templates/core/tasks/setup.rake.seed
+seedling.gemspec
+spec/helper.rb
+tasks/authors.rake
+tasks/bacon.rake
+tasks/changelog.rake
+tasks/copyright.rake
+tasks/gem.rake
+tasks/gem_installer.rake
+tasks/install_dependencies.rake
+tasks/manifest.rake
+tasks/rcov.rake
+tasks/release.rake
+tasks/reversion.rake
+tasks/setup.rake
+tasks/yard.rake

data/README

@@ -0,0 +1,28 @@
+==Seedling
+----------
+
+Seedling is a tool for creating ruby projects.  It aims to add
+tasks (via a Rakefile and some tasks/*.rake) which allow for quick
+and easy publishing of your new ruby library, via github and or rubyforge.
+It automates some of the monotony such as
+ 
+* Re-Versioning
+* AUTHORS updating
+* .gemspec updates
+* building a gem, tarball, zip, source export tree
+* Test (spec) running, via a bacon task and bacon spec helper (we love bacon)
+* Documentation via yard
+* CHANGELOG updating
+
+== Download
+
+using git
+ git clone git://rubyists.com/gits/seedling
+
+==Usage
+-------
+
+We're getting there. Will be
+ seedling plant /path/to/tree
+
+Copyright(c) 2009 The Rubyists

data/Rakefile

@@ -0,0 +1,68 @@
+begin; require 'rubygems'; rescue LoadError; end
+
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'time'
+require 'date'
+require "lib/seedling"
+
+PROJECT_SPECS = FileList[
+  'spec/**/*.rb'
+]
+
+PROJECT_MODULE = 'Seedling'
+PROJECT_README = 'README'
+#PROJECT_RUBYFORGE_GROUP_ID = 3034
+PROJECT_COPYRIGHT = [
+  "#          Copyright (c) #{Time.now.year} The Rubyists rubyists@rubyists.com",
+  "# Distributed under the terms of the MIT license."
+]
+
+# To release the monthly version do:
+# $ PROJECT_VERSION=2009.03 rake release
+IGNORE_FILES = [/\.gitignore/]
+
+GEMSPEC = Gem::Specification.new{|s|
+  s.name         = 'seedling'
+  s.author       = "Kevin Berry"
+  s.summary      = "A lightweight tool to create new ruby library trees, with helpers to make gemming and maintaining a breeze."
+  s.description  = s.summary
+  s.email        = 'deathsyn@gmail.com'
+  s.homepage     = 'http://github.com/deathsyn/seedling'
+  s.platform     = Gem::Platform::RUBY
+  s.version      = (ENV['VERSION'] || (begin;Object.const_get(PROJECT_MODULE)::VERSION;rescue;Date.today.strftime("%Y.%m.%d");end))
+  s.files        = `git ls-files`.split("\n").sort.reject { |f| IGNORE_FILES.detect { |exp| f.match(exp)  } }
+  s.has_rdoc     = true
+  s.require_path = 'lib'
+  s.bindir = "bin"
+  s.executables = ["seedling"]
+  s.rubyforge_project = "seedling"
+
+  s.post_install_message = <<MESSAGE.strip
+============================================================
+
+Thank you for installing Seedling!
+Begin by planting your ruby project with 
+# seedling plant /path/to/new/project
+
+============================================================
+MESSAGE
+}
+
+Dir['tasks/*.rake'].each{|f| import(f) }
+
+task :default => [:bacon]
+
+CLEAN.include %w[
+  **/.*.sw?
+  *.gem
+  .config
+  **/*~
+  **/{data.db,cache.yaml}
+  *.yaml
+  pkg
+  rdoc
+  ydoc
+  *coverage*
+]

data/bin/seedling

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+begin
+  require "pathname"
+  local_seedling = Pathname.new(__FILE__).expand_path.dirname.join("..", "lib", "seedling.rb")
+  if local_seedling.file?
+    require local_seedling
+  else
+    require "seedling"
+  end
+  require "seedling/bin"
+rescue LoadError
+  require "rubygems"
+  require "seedling/bin"
+end
+Seedling::Bin::Cmd.run(ARGV)

data/lib/seedling.rb

@@ -0,0 +1,5 @@
+require "pathname"
+$LOAD_PATH.unshift(Pathname.new(__FILE__).dirname.expand_path.to_s)
+module Seedling
+end
+require "seedling/version"

data/lib/seedling/bin.rb

@@ -0,0 +1,196 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require "seedling/extensions/inflector"
+### This module offers the functionality to create.
+module Seedling
+  module Bin
+    class Cmd # This class contains the command methods {{{
+      #include Helpers
+      attr_accessor :command
+
+      def initialize(args = nil)
+        args ||= ARGV
+        raise "arguments must be an array!" unless args.respond_to?(:detect)
+        @ourargs = args.dup
+        @command = args.detect { |arg| arg.match(/^(?:--?)?(?:plant|create|h(?:elp)?|v(?:ersion)?|console)/) }
+        if command.nil?
+          @command = ""
+        else
+          args.delete(@command)
+        end
+        ARGV.replace(args)
+      end
+
+      # {{{ #run is called when we're interactive ($0 == __FILE__)
+      def self.run(args = nil)
+        cmd = new(args)
+        case cmd.command
+        when /^(?:--?)?(?:plant|create)$/
+          require "seedling/project_creator"
+          cmd.plant(cmd.command)
+        when /^(?:--?)?console$/
+          require "irb"
+          require "irb/completion"
+          cmd.include_seedling
+          IRB.start
+          puts "Seedling session has ended."
+        when /^(?:--?)?h(elp)?$/
+          puts cmd.usage
+        when /^(?:--?)?v(ersion)?$/
+          cmd.include_seedling
+          puts Seedling::VERSION
+          exit
+        when /^$/
+          puts "Must supply a valid command"
+          puts cmd.usage
+          exit 1
+        else
+          puts "#{command} not implemented"
+          puts cmd.usage
+          exit 1
+        end
+      end # }}}
+
+      def include_seedling # {{{
+        begin
+          $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '/../lib')
+          require 'seedling'
+        rescue LoadError
+          $LOAD_PATH.shift
+
+          begin
+            require 'rubygems'
+          rescue LoadError
+          end
+          require 'seedling'
+        end
+      end # }}}
+
+      def usage # {{{
+        txt = [
+          "\n  Usage:", 
+          "seedling <plant|create|console> PROJECT [options]\n",
+          "Commands:\n",
+          " plant   - Creates a new prototype Seedling application in a directory named PROJECT in",
+          "           the current directory.  seedling create foo would make ./foo containing a",
+          "           seedling prototype.\n",
+          " create  - Synonymous with plant.\n",
+          " console - Starts an irb console with seedling (and irb completion) loaded.",
+          "           ARGV is passed on to IRB.\n\n"
+        ].join("\n\t")
+
+        txt <<  "* All commands take PROJECT as the directory the seedling lives in.\n\n"
+        txt << plant_options.to_s << "\n"
+        #if is_windows?
+          #txt << %x{ruby #{rackup_path} --help}.split("\n").reject { |line| line.match(/^Usage:/) }.join("\n\t")
+        #else
+          #txt << %x{#{rackup_path} --help}.split("\n").reject { |line| line.match(/^Usage:/) }.join("\n\t")
+        #end
+      end # }}}
+
+      def al_root
+        require "pathname"
+        dir = nil
+        if ARGV.size == 1
+          dir = Pathname.new(ARGV.shift)
+        elsif ARGV.size > 1
+          $stderr.puts "Unknown options given #{ARGV.join(" ")}"
+          puts usage
+          exit 1
+        end
+        if dir.nil? or not dir.directory?
+          dir = Pathname.new(ENV["PWD"]).expand_path
+          $stderr.puts "Path to seedling tree not given or invalid, using #{dir}"
+        end
+        Object.const_set("AL_ROOT", dir.expand_path.to_s)
+        Dir.chdir(AL_ROOT)
+      end
+
+      ### Methods for commands {{{
+      def plant_options(opts = {})
+        @plant_opts ||= OptionParser.new do |o|
+          o.banner = "Planting Options"
+          o.on("-nSUMMARY", "--summary SUMMARY", "Short description of this project") { |yn| opts[:summary] = yn }
+          o.on("-dDESCRIPTION", "--description DESCRIPTION", "Longer description (Default: summary)") { |des| opts[:description] = des }
+          o.on("-lLIBNAME", "--libname LIBNAME", "Library name (Default: path specifcation)") { |libname| opts[:lib_name] = libname }
+          o.on("-gDOCGENERATOR", "--doc-generator DOCGENERATOR", "Preferred documentation generator (Default: yard)") { |docgenerator| opts[:doc_generator] = docgenerator }
+          o.on("-tTESTSUITE", "--test-suite TESTSUITE", "Preferred test suite (Default: bacon)") { |testsuite| opts[:test_suite] = testsuite }
+          o.on("-vVER", "--version VER", "Initial version number (Default: 0.0.1)") { |ver| opts[:version] = ver }
+          o.on("-rRUBYFORGE", "--rubyforge RUBYFORGE", "Rubyforge project name") { |rubyforge| opts[:rubyforge_project] = rubyforge }
+
+          o.separator ""
+          o.separator "Author Options"
+          o.on("-sAUTHOR", "--summary AUTHOR", "Author's Name") { |yn| opts[:author_name] = yn }
+          o.on("-eEMAIL", "--email EMAIL", "Author's Email") { |yn| opts[:author_email] = yn }
+          o.on("-uURL", "--url URL", "Project URL/homepage") { |url| opts[:project_url] = url }
+
+          o.separator ""
+          o.separator "Directory Creation Options"
+          o.on("-f", "--force", "Force creation if dir already exists") { |yn| opts[:force] = true }
+          o.on("-a", "--amend", "Update a tree") { |yn| opts[:amend] = true }
+        end
+      end
+      
+      def plant(command) # {{{
+        plant_options(o = {}).parse!(ARGV)
+        unless ARGV.size == 1
+          $stderr.puts "Invalid options given: #{ARGV.join(" ")}"
+          exit 1
+        end
+        project_root = ARGV.shift
+        if project_root.nil?
+          $stderr.puts "Must supply a valid directory to install your project, you gave none."
+          puts usage
+          exit 1
+        end
+        o[:lib_name] ||= Pathname.new(project_root).basename.to_s.classify
+        o[:lib_name_u] ||= o[:lib_name].underscore
+        opts = plant_defaults(o)
+        # need to titleize this
+        include_seedling
+        Seedling::ProjectCreator.new(project_root, opts).create
+      end # }}}
+
+      private
+
+      # Sets all of our default settings to make a sane rakefile, pulling from everywhere that makes sense
+      def plant_defaults(o = {:lib_name => "Seedling"})
+        # this shouldn't happen, but if so let's be descriptive
+        raise "plant_defaults requires a :lib_name in the calling argument" unless o[:lib_name]
+        o[:lib_name_u] = o[:lib_name].underscore
+        [:author_name, :author_email].each do |opt|
+          o[opt] = self.send(opt)
+        end
+        o[:summary] ||= "The #{o[:lib_name].classify.titleize} library, by #{o[:author_name]}"
+        o[:description] ||= o[:summary]
+        o[:version] ||= "0.0.1"
+        o[:test_suite] ||= "bacon"
+        o[:doc_generator] ||= "yard"
+        o
+      end
+
+      def author_email
+        gitted = %x{git config --global --get user.email}
+        return gitted.to_s.strip if gitted.to_s.match(/\w/)
+        return ENV["EMAIL"] if ENV["EMAIL"]
+        return [ENV["LOGUSER"], ENV["HOSTNAME"]].join("@") if ENV["LOGUSER"] and ENV["HOSTNAME"]
+        raise "Cannot find author email, please  use --email \"you@your.domain.com\" or set the EMAIL environment variable"
+      end
+
+      def author_name
+        gitted = %x{git config --global --get user.name}
+        return gitted.to_s.strip if gitted.to_s.match(/\w/)
+        return ENV["NAME"] if ENV["NAME"]
+        return ENV["LOGUSER"] if ENV["LOGUSER"]
+        return Pathname.new(ENV["HOME"]).expand_path.basename.to_s if ENV["HOME"]
+        raise "Cannot find author name, please  use --author \"Your Name\" or set the NAME or LOGUSER environment variables"
+      end
+
+      ### End of command methods }}}
+    end # }}}
+  end
+end
+
+if $0 == __FILE__
+  Seedling::Bin::Cmd.run(ARGV)
+end

data/lib/seedling/extensions/inflector.rb

@@ -0,0 +1,283 @@
+# Add inflection methods to String, which allows the easy transformation of
+# words from singular to plural,class names to table names, modularized class
+# names to ones without, and class names to foreign keys.
+
+class String
+  # This module acts as a singleton returned/yielded by String.inflections,
+  # which is used to override or specify additional inflection rules. Examples:
+  #
+  #   String.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.
+  module Inflections
+    @plurals, @singulars, @uncountables = [], [], []
+
+    class << self
+      attr_reader :plurals, :singulars, :uncountables
+    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 self.clear(scope = :all)
+      case scope
+      when :all
+        @plurals, @singulars, @uncountables = [], [], []
+      else
+        instance_variable_set("@#{scope}", [])
+      end
+    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 self.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
+
+    # 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.
+    #
+    # Example:
+    #   plural(/(x|ch|ss|sh)$/i, '\1es')
+    def self.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.
+    #
+    # Example:
+    #   singular(/([^aeiouy]|qu)ies$/i, '\1y') 
+    def self.singular(rule, replacement)
+      @singulars.insert(0, [rule, replacement])
+    end
+
+    # Add uncountable words that shouldn't be attempted inflected.
+    #
+    # Examples:
+    #   uncountable "money"
+    #   uncountable "money", "information"
+    #   uncountable %w( money information rice )
+    def self.uncountable(*words)
+      (@uncountables << words).flatten!
+    end
+
+    # Setup the default inflections
+    plural(/$/, 's')
+    plural(/s$/i, 's')
+    plural(/(ax|test)is$/i, '\1es')
+    plural(/(octop|vir)us$/i, '\1i')
+    plural(/(alias|status)$/i, '\1es')
+    plural(/(bu)s$/i, '\1ses')
+    plural(/(buffal|tomat)o$/i, '\1oes')
+    plural(/([ti])um$/i, '\1a')
+    plural(/sis$/i, 'ses')
+    plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+    plural(/(hive)$/i, '\1s')
+    plural(/([^aeiouy]|qu)y$/i, '\1ies')
+    plural(/(x|ch|ss|sh)$/i, '\1es')
+    plural(/(matr|vert|ind)ix|ex$/i, '\1ices')
+    plural(/([m|l])ouse$/i, '\1ice')
+    plural(/^(ox)$/i, '\1en')
+    plural(/(quiz)$/i, '\1zes')
+
+    singular(/s$/i, '')
+    singular(/(n)ews$/i, '\1ews')
+    singular(/([ti])a$/i, '\1um')
+    singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
+    singular(/(^analy)ses$/i, '\1sis')
+    singular(/([^f])ves$/i, '\1fe')
+    singular(/(hive)s$/i, '\1')
+    singular(/(tive)s$/i, '\1')
+    singular(/([lr])ves$/i, '\1f')
+    singular(/([^aeiouy]|qu)ies$/i, '\1y')
+    singular(/(s)eries$/i, '\1eries')
+    singular(/(m)ovies$/i, '\1ovie')
+    singular(/(x|ch|ss|sh)es$/i, '\1')
+    singular(/([m|l])ice$/i, '\1ouse')
+    singular(/(bus)es$/i, '\1')
+    singular(/(o)es$/i, '\1')
+    singular(/(shoe)s$/i, '\1')
+    singular(/(cris|ax|test)es$/i, '\1is')
+    singular(/(octop|vir)i$/i, '\1us')
+    singular(/(alias|status)es$/i, '\1')
+    singular(/^(ox)en/i, '\1')
+    singular(/(vert|ind)ices$/i, '\1ex')
+    singular(/(matr)ices$/i, '\1ix')
+    singular(/(quiz)zes$/i, '\1')
+
+    irregular('person', 'people')
+    irregular('man', 'men')
+    irregular('child', 'children')
+    irregular('sex', 'sexes')
+    irregular('move', 'moves')
+
+    uncountable(%w(equipment information rice money species series fish sheep))
+  end
+
+  # Yield the Inflections module if a block is given, and return
+  # the Inflections module.
+  def self.inflections
+    yield Inflections if block_given?
+    Inflections
+  end
+
+  # By default, camelize converts the string 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(first_letter_in_uppercase = :upper)
+    s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
+    s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
+    s
+  end
+  alias_method :camelcase, :camelize
+
+  # Singularizes and camelizes the string.  Also strips out all characters preceding
+  # and including a period (".").
+  #
+  # Examples
+  #   "egg_and_hams".classify #=> "EggAndHam"
+  #   "post".classify #=> "Post"
+  #   "schema.post".classify #=> "Post"
+  def classify
+    sub(/.*\./, '').singularize.camelize
+  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
+    raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(self)
+    Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
+  end
+
+  # Replaces underscores with dashes in the string.
+  #
+  # Example
+  #   "puni_puni".dasherize #=> "puni-puni"
+  def dasherize
+    gsub(/_/, '-')
+  end
+
+  # Removes the module part from the expression in the string
+  #
+  # Examples
+  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
+  #   "Inflections".demodulize #=> "Inflections"
+  def demodulize
+    gsub(/^.*::/, '')
+  end
+
+  # Creates a foreign key name from a class name.
+  # +use_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(use_underscore = true)
+    "#{demodulize.underscore}#{'_' if use_underscore}id"
+  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
+    gsub(/_id$/, "").gsub(/_/, " ").capitalize
+  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
+    result = dup
+    Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
+    result
+  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
+    result = dup
+    Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
+    result
+  end
+
+  # Underscores and pluralizes the string.
+  #
+  # Examples
+  #   "RawScaledScorer".tableize #=> "raw_scaled_scorers"
+  #   "egg_and_ham".tableize #=> "egg_and_hams"
+  #   "fancyCategory".tableize #=> "fancy_categories"
+  def tableize
+    underscore.pluralize
+  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.
+  #
+  # 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
+    underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
+  end
+  alias_method :titlecase, :titleize
+
+  # The reverse of camelize. Makes an underscored form from the expression in the string.
+  # Also changes '::' to '/' to convert namespaces to paths.
+  #
+  # Examples
+  #   "ActiveRecord".underscore #=> "active_record"
+  #   "ActiveRecord::Errors".underscore #=> active_record/errors
+  def underscore
+    gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+  end
+end