rq 3.1.0 → 3.3.0

data/rails/vendor/rails/railties/lib/rails/version.rb

@@ -0,0 +1,9 @@
+module Rails
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 2
+    TINY  = 3
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/rails/vendor/rails/railties/lib/rails_generator.rb

@@ -0,0 +1,43 @@
+#--
+# Copyright (c) 2004 Jeremy Kemper
+#
+# 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.
+#++
+
+$:.unshift(File.dirname(__FILE__))
+$:.unshift(File.dirname(__FILE__) + "/../../activesupport/lib")
+
+begin
+  require 'active_support'  
+rescue LoadError
+  require 'rubygems'
+  gem 'activesupport'
+end
+
+require 'rails_generator/base'
+require 'rails_generator/lookup'
+require 'rails_generator/commands'
+
+Rails::Generator::Base.send(:include, Rails::Generator::Lookup)
+Rails::Generator::Base.send(:include, Rails::Generator::Commands)
+
+# Set up a default logger for convenience.
+require 'rails_generator/simple_logger'
+Rails::Generator::Base.logger = Rails::Generator::SimpleLogger.new(STDOUT)

data/rails/vendor/rails/railties/lib/rails_generator/base.rb

@@ -0,0 +1,261 @@
+require File.dirname(__FILE__) + '/options'
+require File.dirname(__FILE__) + '/manifest'
+require File.dirname(__FILE__) + '/spec'
+require File.dirname(__FILE__) + '/generated_attribute'
+
+module Rails
+  # Rails::Generator is a code generation platform tailored for the Rails
+  # web application framework.  Generators are easily invoked within Rails
+  # applications to add and remove components such as models and controllers.
+  # New generators are easy to create and may be distributed as RubyGems,
+  # tarballs, or Rails plugins for inclusion system-wide, per-user, 
+  # or per-application.
+  #
+  # For actual examples see the rails_generator/generators directory in the
+  # Rails source (or the +railties+ directory if you have frozen the Rails
+  # source in your application).
+  #
+  # Generators may subclass other generators to provide variations that
+  # require little or no new logic but replace the template files.
+  #
+  # For a RubyGem, put your generator class and templates in the +lib+
+  # directory. For a Rails plugin, make a +generators+ directory at the 
+  # root of your plugin.
+  #
+  # The layout of generator files can be seen in the built-in 
+  # +controller+ generator:
+  #   
+  #   generators/
+  #     controller/
+  #       controller_generator.rb
+  #       templates/
+  #         controller.rb
+  #         functional_test.rb
+  #         helper.rb
+  #         view.rhtml
+  #
+  # The directory name (+controller+) matches the name of the generator file
+  # (controller_generator.rb) and class (+ControllerGenerator+). The files
+  # that will be copied or used as templates are stored in the +templates+
+  # directory.
+  #
+  # The filenames of the templates don't matter, but choose something that
+  # will be self-explatatory since you will be referencing these in the 
+  # +manifest+ method inside your generator subclass.
+  #
+  # 
+  module Generator
+    class GeneratorError < StandardError; end
+    class UsageError < GeneratorError; end
+
+
+    # The base code generator is bare-bones.  It sets up the source and
+    # destination paths and tells the logger whether to keep its trap shut.
+    #
+    # It's useful for copying files such as stylesheets, images, or 
+    # javascripts.
+    #
+    # For more comprehensive template-based passive code generation with
+    # arguments, you'll want Rails::Generator::NamedBase. 
+    #
+    # Generators create a manifest of the actions they perform then hand
+    # the manifest to a command which replays the actions to do the heavy
+    # lifting (such as checking for existing files or creating directories
+    # if needed). Create, destroy, and list commands are included.  Since a
+    # single manifest may be used by any command, creating new generators is
+    # as simple as writing some code templates and declaring what you'd like
+    # to do with them.
+    #
+    # The manifest method must be implemented by subclasses, returning a
+    # Rails::Generator::Manifest.  The +record+ method is provided as a
+    # convenience for manifest creation.  Example:
+    #
+    #   class StylesheetGenerator < Rails::Generator::Base
+    #     def manifest
+    #       record do |m|
+    #         m.directory('public/stylesheets')
+    #         m.file('application.css', 'public/stylesheets/application.css')
+    #       end
+    #     end
+    #   end
+    #
+    # See Rails::Generator::Commands::Create for a list of methods available
+    # to the manifest.
+    class Base
+      include Options
+
+      # Declare default options for the generator.  These options
+      # are inherited to subclasses.
+      default_options :collision => :ask, :quiet => false
+
+      # A logger instance available everywhere in the generator.
+      cattr_accessor :logger
+
+      # Every generator that is dynamically looked up is tagged with a
+      # Spec describing where it was found.
+      class_inheritable_accessor :spec
+
+      attr_reader :source_root, :destination_root, :args
+
+      def initialize(runtime_args, runtime_options = {})
+        @args = runtime_args
+        parse!(@args, runtime_options)
+
+        # Derive source and destination paths.
+        @source_root = options[:source] || File.join(spec.path, 'templates')
+        if options[:destination]
+          @destination_root = options[:destination]
+        elsif defined? ::RAILS_ROOT
+          @destination_root = ::RAILS_ROOT
+        end
+
+        # Silence the logger if requested.
+        logger.quiet = options[:quiet]
+
+        # Raise usage error if help is requested.
+        usage if options[:help]
+      end
+
+      # Generators must provide a manifest.  Use the +record+ method to create
+      # a new manifest and record your generator's actions.
+      def manifest
+        raise NotImplementedError, "No manifest for '#{spec.name}' generator."
+      end
+
+      # Return the full path from the source root for the given path.
+      # Example for source_root = '/source':
+      #   source_path('some/path.rb') == '/source/some/path.rb'
+      #
+      # The given path may include a colon ':' character to indicate that
+      # the file belongs to another generator.  This notation allows any
+      # generator to borrow files from another.  Example:
+      #   source_path('model:fixture.yml') = '/model/source/path/fixture.yml'
+      def source_path(relative_source)
+        # Check whether we're referring to another generator's file.
+        name, path = relative_source.split(':', 2)
+
+        # If not, return the full path to our source file.
+        if path.nil?
+          File.join(source_root, name)
+
+        # Otherwise, ask our referral for the file.
+        else
+          # FIXME: this is broken, though almost always true.  Others'
+          # source_root are not necessarily the templates dir.
+          File.join(self.class.lookup(name).path, 'templates', path)
+        end
+      end
+
+      # Return the full path from the destination root for the given path.
+      # Example for destination_root = '/dest':
+      #   destination_path('some/path.rb') == '/dest/some/path.rb'
+      def destination_path(relative_destination)
+        File.join(destination_root, relative_destination)
+      end
+
+      protected
+        # Convenience method for generator subclasses to record a manifest.
+        def record
+          Rails::Generator::Manifest.new(self) { |m| yield m }
+        end
+
+        # Override with your own usage banner.
+        def banner
+          "Usage: #{$0} #{spec.name} [options]"
+        end
+
+        # Read USAGE from file in generator base path.
+        def usage_message
+          File.read(File.join(spec.path, 'USAGE')) rescue ''
+        end
+    end
+
+
+    # The base generator for named components: models, controllers, mailers,
+    # etc.  The target name is taken as the first argument and inflected to
+    # singular, plural, class, file, and table forms for your convenience.
+    # The remaining arguments are aliased to +actions+ as an array for 
+    # controller and mailer convenience.
+    #
+    # Several useful local variables and methods are populated in the 
+    # +initialize+ method. See below for a list of Attributes and
+    # External Aliases available to both the manifest and to all templates.    
+    #
+    # If no name is provided, the generator raises a usage error with content
+    # optionally read from the USAGE file in the generator's base path.
+    #
+    # For example, the +controller+ generator takes the first argument as 
+    # the name of the class and subsequent arguments as the names of
+    # actions to be generated:
+    #
+    #   ./script/generate controller Article index new create
+    #
+    # See Rails::Generator::Base for a discussion of manifests, 
+    # Rails::Generator::Commands::Create for methods available to the manifest,
+    # and Rails::Generator for a general discussion of generators.
+    class NamedBase < Base
+      attr_reader   :name, :class_name, :singular_name, :plural_name, :table_name
+      attr_reader   :class_path, :file_path, :class_nesting, :class_nesting_depth
+      alias_method  :file_name,  :singular_name
+      alias_method  :actions, :args
+
+      def initialize(runtime_args, runtime_options = {})
+        super
+
+        # Name argument is required.
+        usage if runtime_args.empty?
+
+        @args = runtime_args.dup
+        base_name = @args.shift
+        assign_names!(base_name)
+      end
+
+      protected
+        # Override with your own usage banner.
+        def banner
+          "Usage: #{$0} #{spec.name} #{spec.name.camelize}Name [options]"
+        end
+    
+        def attributes
+          @attributes ||= @args.collect do |attribute|
+            Rails::Generator::GeneratedAttribute.new(*attribute.split(":"))
+          end
+        end
+
+
+      private
+        def assign_names!(name)
+          @name = name
+          base_name, @class_path, @file_path, @class_nesting, @class_nesting_depth = extract_modules(@name)
+          @class_name_without_nesting, @singular_name, @plural_name = inflect_names(base_name)
+          @table_name = ActiveRecord::Base.pluralize_table_names ? plural_name : singular_name
+          if @class_nesting.empty?
+            @class_name = @class_name_without_nesting
+          else
+            @table_name = @class_nesting.underscore << "_" << @table_name
+            @class_name = "#{@class_nesting}::#{@class_name_without_nesting}"
+          end
+        end
+
+        # Extract modules from filesystem-style or ruby-style path:
+        #   good/fun/stuff
+        #   Good::Fun::Stuff
+        # produce the same results.
+        def extract_modules(name)
+          modules = name.include?('/') ? name.split('/') : name.split('::')
+          name    = modules.pop
+          path    = modules.map { |m| m.underscore }
+          file_path = (path + [name.underscore]).join('/')
+          nesting = modules.map { |m| m.camelize }.join('::')
+          [name, path, file_path, nesting, modules.size]
+        end
+
+        def inflect_names(name)
+          camel  = name.camelize
+          under  = camel.underscore
+          plural = under.pluralize
+          [camel, under, plural]
+        end
+    end
+  end
+end

data/rails/vendor/rails/railties/lib/rails_generator/commands.rb

@@ -0,0 +1,581 @@
+require 'delegate'
+require 'optparse'
+require 'fileutils'
+require 'tempfile'
+require 'erb'
+
+module Rails
+  module Generator
+    module Commands
+      # Here's a convenient way to get a handle on generator commands.
+      # Command.instance('destroy', my_generator) instantiates a Destroy
+      # delegate of my_generator ready to do your dirty work.
+      def self.instance(command, generator)
+        const_get(command.to_s.camelize).new(generator)
+      end
+
+      # Even more convenient access to commands.  Include Commands in
+      # the generator Base class to get a nice #command instance method
+      # which returns a delegate for the requested command.
+      def self.included(base)
+        base.send(:define_method, :command) do |command|
+          Commands.instance(command, self)
+        end
+      end
+
+
+      # Generator commands delegate Rails::Generator::Base and implement
+      # a standard set of actions.  Their behavior is defined by the way
+      # they respond to these actions: Create brings life; Destroy brings
+      # death; List passively observes.
+      #
+      # Commands are invoked by replaying (or rewinding) the generator's
+      # manifest of actions.  See Rails::Generator::Manifest and
+      # Rails::Generator::Base#manifest method that generator subclasses
+      # are required to override.
+      #
+      # Commands allows generators to "plug in" invocation behavior, which
+      # corresponds to the GoF Strategy pattern.
+      class Base < DelegateClass(Rails::Generator::Base)
+        # Replay action manifest.  RewindBase subclass rewinds manifest.
+        def invoke!
+          manifest.replay(self)
+        end
+
+        def dependency(generator_name, args, runtime_options = {})
+          logger.dependency(generator_name) do
+            self.class.new(instance(generator_name, args, full_options(runtime_options))).invoke!
+          end
+        end
+
+        # Does nothing for all commands except Create.
+        def class_collisions(*class_names)
+        end
+
+        # Does nothing for all commands except Create.
+        def readme(*args)
+        end
+
+        protected
+          def migration_directory(relative_path)
+            directory(@migration_directory = relative_path)
+          end
+
+          def existing_migrations(file_name)
+            Dir.glob("#{@migration_directory}/[0-9]*_*.rb").grep(/[0-9]+_#{file_name}.rb$/)
+          end
+
+          def migration_exists?(file_name)
+            not existing_migrations(file_name).empty?
+          end
+
+          def current_migration_number
+            Dir.glob("#{@migration_directory}/[0-9]*.rb").inject(0) do |max, file_path|
+              n = File.basename(file_path).split('_', 2).first.to_i
+              if n > max then n else max end
+            end
+          end
+
+          def next_migration_number
+            current_migration_number + 1
+          end
+
+          def next_migration_string(padding = 3)
+            "%.#{padding}d" % next_migration_number
+          end
+
+          def gsub_file(relative_destination, regexp, *args, &block)
+            path = destination_path(relative_destination)
+            content = File.read(path).gsub(regexp, *args, &block)
+            File.open(path, 'wb') { |file| file.write(content) }
+          end
+
+        private
+          # Ask the user interactively whether to force collision.
+          def force_file_collision?(destination, src, dst, file_options = {}, &block)
+            $stdout.print "overwrite #{destination}? [Ynaqd] "
+            case $stdin.gets
+              when /d/i
+                Tempfile.open(File.basename(destination), File.dirname(dst)) do |temp|
+                  temp.write render_file(src, file_options, &block)
+                  temp.rewind
+                  $stdout.puts `#{diff_cmd} #{dst} #{temp.path}`
+                end
+                puts "retrying"
+                raise 'retry diff'
+              when /a/i
+                $stdout.puts "forcing #{spec.name}"
+                options[:collision] = :force
+              when /q/i
+                $stdout.puts "aborting #{spec.name}"
+                raise SystemExit
+              when /n/i then :skip
+              else :force
+            end
+          rescue
+            retry
+          end
+
+          def diff_cmd
+            ENV['RAILS_DIFF'] || 'diff -u'
+          end
+
+          def render_template_part(template_options)
+            # Getting Sandbox to evaluate part template in it
+            part_binding = template_options[:sandbox].call.sandbox_binding
+            part_rel_path = template_options[:insert]
+            part_path = source_path(part_rel_path)
+
+            # Render inner template within Sandbox binding
+            rendered_part = ERB.new(File.readlines(part_path).join, nil, '-').result(part_binding)
+            begin_mark = template_part_mark(template_options[:begin_mark], template_options[:mark_id])
+            end_mark = template_part_mark(template_options[:end_mark], template_options[:mark_id])
+            begin_mark + rendered_part + end_mark
+          end
+
+          def template_part_mark(name, id)
+            "<!--[#{name}:#{id}]-->\n"
+          end
+      end
+
+      # Base class for commands which handle generator actions in reverse, such as Destroy.
+      class RewindBase < Base
+        # Rewind action manifest.
+        def invoke!
+          manifest.rewind(self)
+        end
+      end
+
+
+      # Create is the premier generator command.  It copies files, creates
+      # directories, renders templates, and more.
+      class Create < Base
+
+        # Check whether the given class names are already taken by
+        # Ruby or Rails.  In the future, expand to check other namespaces
+        # such as the rest of the user's app.
+        def class_collisions(*class_names)
+          class_names.flatten.each do |class_name|
+            # Convert to string to allow symbol arguments.
+            class_name = class_name.to_s
+
+            # Skip empty strings.
+            next if class_name.strip.empty?
+
+            # Split the class from its module nesting.
+            nesting = class_name.split('::')
+            name = nesting.pop
+
+            # Extract the last Module in the nesting.
+            last = nesting.inject(Object) { |last, nest|
+              break unless last.const_defined?(nest)
+              last.const_get(nest)
+            }
+
+            # If the last Module exists, check whether the given
+            # class exists and raise a collision if so.
+            if last and last.const_defined?(name.camelize)
+              raise_class_collision(class_name)
+            end
+          end
+        end
+
+        # Copy a file from source to destination with collision checking.
+        #
+        # The file_options hash accepts :chmod and :shebang and :collision options.
+        # :chmod sets the permissions of the destination file:
+        #   file 'config/empty.log', 'log/test.log', :chmod => 0664
+        # :shebang sets the #!/usr/bin/ruby line for scripts
+        #   file 'bin/generate.rb', 'script/generate', :chmod => 0755, :shebang => '/usr/bin/env ruby'
+        # :collision sets the collision option only for the destination file: 
+        #   file 'settings/server.yml', 'config/server.yml', :collision => :skip
+        #
+        # Collisions are handled by checking whether the destination file
+        # exists and either skipping the file, forcing overwrite, or asking
+        # the user what to do.
+        def file(relative_source, relative_destination, file_options = {}, &block)
+          # Determine full paths for source and destination files.
+          source              = source_path(relative_source)
+          destination         = destination_path(relative_destination)
+          destination_exists  = File.exists?(destination)
+
+          # If source and destination are identical then we're done.
+          if destination_exists and identical?(source, destination, &block)
+            return logger.identical(relative_destination) 
+          end
+
+          # Check for and resolve file collisions.
+          if destination_exists
+
+            # Make a choice whether to overwrite the file.  :force and
+            # :skip already have their mind made up, but give :ask a shot.
+            choice = case (file_options[:collision] || options[:collision]).to_sym #|| :ask
+              when :ask   then force_file_collision?(relative_destination, source, destination, file_options, &block)
+              when :force then :force
+              when :skip  then :skip
+              else raise "Invalid collision option: #{options[:collision].inspect}"
+            end
+
+            # Take action based on our choice.  Bail out if we chose to
+            # skip the file; otherwise, log our transgression and continue.
+            case choice
+              when :force then logger.force(relative_destination)
+              when :skip  then return(logger.skip(relative_destination))
+              else raise "Invalid collision choice: #{choice}.inspect"
+            end
+
+          # File doesn't exist so log its unbesmirched creation.
+          else
+            logger.create relative_destination
+          end
+
+          # If we're pretending, back off now.
+          return if options[:pretend]
+
+          # Write destination file with optional shebang.  Yield for content
+          # if block given so templaters may render the source file.  If a
+          # shebang is requested, replace the existing shebang or insert a
+          # new one.
+          File.open(destination, 'wb') do |dest|
+            dest.write render_file(source, file_options, &block)
+          end
+
+          # Optionally change permissions.
+          if file_options[:chmod]
+            FileUtils.chmod(file_options[:chmod], destination)
+          end
+
+          # Optionally add file to subversion
+          system("svn add #{destination}") if options[:svn]
+        end
+
+        # Checks if the source and the destination file are identical. If
+        # passed a block then the source file is a template that needs to first
+        # be evaluated before being compared to the destination.
+        def identical?(source, destination, &block)
+          return false if File.directory? destination
+          source      = block_given? ? File.open(source) {|sf| yield(sf)} : IO.read(source)
+          destination = IO.read(destination)
+          source == destination
+        end
+
+        # Generate a file for a Rails application using an ERuby template.
+        # Looks up and evalutes a template by name and writes the result.
+        #
+        # The ERB template uses explicit trim mode to best control the
+        # proliferation of whitespace in generated code.  <%- trims leading
+        # whitespace; -%> trims trailing whitespace including one newline.
+        #
+        # A hash of template options may be passed as the last argument.
+        # The options accepted by the file are accepted as well as :assigns,
+        # a hash of variable bindings.  Example:
+        #   template 'foo', 'bar', :assigns => { :action => 'view' }
+        #
+        # Template is implemented in terms of file.  It calls file with a
+        # block which takes a file handle and returns its rendered contents.
+        def template(relative_source, relative_destination, template_options = {})
+          file(relative_source, relative_destination, template_options) do |file|
+            # Evaluate any assignments in a temporary, throwaway binding.
+            vars = template_options[:assigns] || {}
+            b = binding
+            vars.each { |k,v| eval "#{k} = vars[:#{k}] || vars['#{k}']", b }
+
+            # Render the source file with the temporary binding.
+            ERB.new(file.read, nil, '-').result(b)
+          end
+        end
+
+        def complex_template(relative_source, relative_destination, template_options = {})
+          options = template_options.dup
+          options[:assigns] ||= {}
+          options[:assigns]['template_for_inclusion'] = render_template_part(template_options)
+          template(relative_source, relative_destination, options)
+        end
+
+        # Create a directory including any missing parent directories.
+        # Always directories which exist.
+        def directory(relative_path)
+          path = destination_path(relative_path)
+          if File.exists?(path)
+            logger.exists relative_path
+          else
+            logger.create relative_path
+	    unless options[:pretend]
+	      FileUtils.mkdir_p(path)
+	      
+	      # Subversion doesn't do path adds, so we need to add
+	      # each directory individually.
+	      # So stack up the directory tree and add the paths to
+	      # subversion in order without recursion.
+	      if options[:svn]
+		stack=[relative_path]
+		until File.dirname(stack.last) == stack.last # dirname('.') == '.'
+		  stack.push File.dirname(stack.last)
+		end
+		stack.reverse_each do |rel_path|
+		  svn_path = destination_path(rel_path)
+		  system("svn add -N #{svn_path}") unless File.directory?(File.join(svn_path, '.svn'))
+		end
+	      end
+	    end
+	  end
+	end
+
+        # Display a README.
+        def readme(*relative_sources)
+          relative_sources.flatten.each do |relative_source|
+            logger.readme relative_source
+            puts File.read(source_path(relative_source)) unless options[:pretend]
+          end
+        end
+
+        # When creating a migration, it knows to find the first available file in db/migrate and use the migration.rb template.
+        def migration_template(relative_source, relative_destination, template_options = {})
+          migration_directory relative_destination
+          migration_file_name = template_options[:migration_file_name] || file_name
+          raise "Another migration is already named #{migration_file_name}: #{existing_migrations(migration_file_name).first}" if migration_exists?(migration_file_name)
+          template(relative_source, "#{relative_destination}/#{next_migration_string}_#{migration_file_name}.rb", template_options)
+        end
+
+        def route_resources(*resources)
+          resource_list = resources.map { |r| r.to_sym.inspect }.join(', ')
+          sentinel = 'ActionController::Routing::Routes.draw do |map|'
+
+          logger.route "map.resources #{resource_list}"
+          unless options[:pretend]
+            gsub_file 'config/routes.rb', /(#{Regexp.escape(sentinel)})/mi do |match|
+              "#{match}\n  map.resources #{resource_list}\n"
+            end
+          end
+        end
+
+        private
+          def render_file(path, options = {})
+            File.open(path, 'rb') do |file|
+              if block_given?
+                yield file
+              else
+                content = ''
+                if shebang = options[:shebang]
+                  content << "#!#{shebang}\n"
+                  if line = file.gets
+                    content << "line\n" if line !~ /^#!/
+                  end
+                end
+                content << file.read
+              end
+            end
+          end
+
+          # Raise a usage error with an informative WordNet suggestion.
+          # Thanks to Florian Gross (flgr).
+          def raise_class_collision(class_name)
+            message = <<end_message
+  The name '#{class_name}' is reserved by Ruby on Rails.
+  Please choose an alternative and run this generator again.
+end_message
+            if suggest = find_synonyms(class_name)
+              message << "\n  Suggestions:  \n\n"
+              message << suggest.join("\n")
+            end
+            raise UsageError, message
+          end
+
+          SYNONYM_LOOKUP_URI = "http://wordnet.princeton.edu/cgi-bin/webwn2.0?stage=2&word=%s&posnumber=1&searchtypenumber=2&senses=&showglosses=1"
+
+          # Look up synonyms on WordNet.  Thanks to Florian Gross (flgr).
+          def find_synonyms(word)
+            require 'open-uri'
+            require 'timeout'
+            timeout(5) do
+              open(SYNONYM_LOOKUP_URI % word) do |stream|
+                data = stream.read.gsub("&nbsp;", " ").gsub("<BR>", "")
+                data.scan(/^Sense \d+\n.+?\n\n/m)
+              end
+            end
+          rescue Exception
+            return nil
+          end
+      end
+
+
+      # Undo the actions performed by a generator.  Rewind the action
+      # manifest and attempt to completely erase the results of each action.
+      class Destroy < RewindBase
+        # Remove a file if it exists and is a file.
+        def file(relative_source, relative_destination, file_options = {})
+          destination = destination_path(relative_destination)
+          if File.exists?(destination)
+            logger.rm relative_destination
+            unless options[:pretend]
+              if options[:svn]
+                # If the file has been marked to be added
+                # but has not yet been checked in, revert and delete
+                if options[:svn][relative_destination]
+                  system("svn revert #{destination}")
+                  FileUtils.rm(destination)
+                else
+                # If the directory is not in the status list, it
+                # has no modifications so we can simply remove it
+                  system("svn rm #{destination}")
+                end  
+              else
+                FileUtils.rm(destination)
+              end
+            end
+          else
+            logger.missing relative_destination
+            return
+          end
+        end
+
+        # Templates are deleted just like files and the actions take the
+        # same parameters, so simply alias the file method.
+        alias_method :template, :file
+
+        # Remove each directory in the given path from right to left.
+        # Remove each subdirectory if it exists and is a directory.
+        def directory(relative_path)
+          parts = relative_path.split('/')
+          until parts.empty?
+            partial = File.join(parts)
+            path = destination_path(partial)
+            if File.exists?(path)
+              if Dir[File.join(path, '*')].empty?
+                logger.rmdir partial
+                unless options[:pretend]
+                  if options[:svn]
+                    # If the directory has been marked to be added
+                    # but has not yet been checked in, revert and delete
+                    if options[:svn][relative_path]
+                      system("svn revert #{path}")
+                      FileUtils.rmdir(path)
+                    else
+                    # If the directory is not in the status list, it
+                    # has no modifications so we can simply remove it
+                      system("svn rm #{path}")
+                    end
+                  else
+                    FileUtils.rmdir(path)
+                  end
+                end
+              else
+                logger.notempty partial
+              end
+            else
+              logger.missing partial
+            end
+            parts.pop
+          end
+        end
+
+        def complex_template(*args)
+          # nothing should be done here
+        end
+
+        # When deleting a migration, it knows to delete every file named "[0-9]*_#{file_name}".
+        def migration_template(relative_source, relative_destination, template_options = {})
+          migration_directory relative_destination
+
+          migration_file_name = template_options[:migration_file_name] || file_name
+          unless migration_exists?(migration_file_name)
+            puts "There is no migration named #{migration_file_name}"
+            return
+          end
+
+
+          existing_migrations(migration_file_name).each do |file_path|
+            file(relative_source, file_path, template_options)
+          end
+        end
+
+        def route_resources(*resources)
+          resource_list = resources.map { |r| r.to_sym.inspect }.join(', ')
+          look_for = "\n  map.resources #{resource_list}\n"
+          logger.route "map.resources #{resource_list}"
+          gsub_file 'config/routes.rb', /(#{look_for})/mi, ''
+        end
+      end
+
+
+      # List a generator's action manifest.
+      class List < Base
+        def dependency(generator_name, args, options = {})
+          logger.dependency "#{generator_name}(#{args.join(', ')}, #{options.inspect})"
+        end
+
+        def class_collisions(*class_names)
+          logger.class_collisions class_names.join(', ')
+        end
+
+        def file(relative_source, relative_destination, options = {})
+          logger.file relative_destination
+        end
+
+        def template(relative_source, relative_destination, options = {})
+          logger.template relative_destination
+        end
+
+        def complex_template(relative_source, relative_destination, options = {})
+          logger.template "#{options[:insert]} inside #{relative_destination}"
+        end
+
+        def directory(relative_path)
+          logger.directory "#{destination_path(relative_path)}/"
+        end
+
+        def readme(*args)
+          logger.readme args.join(', ')
+        end
+        
+        def migration_template(relative_source, relative_destination, options = {})
+          migration_directory relative_destination
+          logger.migration_template file_name
+        end
+
+        def route_resources(*resources)
+          resource_list = resources.map { |r| r.to_sym.inspect }.join(', ')
+          logger.route "map.resources #{resource_list}"
+        end
+      end
+
+      # Update generator's action manifest.
+      class Update < Create
+        def file(relative_source, relative_destination, options = {})
+          # logger.file relative_destination
+        end
+
+        def template(relative_source, relative_destination, options = {})
+          # logger.template relative_destination
+        end
+
+        def complex_template(relative_source, relative_destination, template_options = {})
+
+           begin
+             dest_file = destination_path(relative_destination)
+             source_to_update = File.readlines(dest_file).join
+           rescue Errno::ENOENT
+             logger.missing relative_destination
+             return
+           end
+
+           logger.refreshing "#{template_options[:insert].gsub(/\.rhtml/,'')} inside #{relative_destination}"
+
+           begin_mark = Regexp.quote(template_part_mark(template_options[:begin_mark], template_options[:mark_id]))
+           end_mark = Regexp.quote(template_part_mark(template_options[:end_mark], template_options[:mark_id]))
+
+           # Refreshing inner part of the template with freshly rendered part.
+           rendered_part = render_template_part(template_options)
+           source_to_update.gsub!(/#{begin_mark}.*?#{end_mark}/m, rendered_part)
+
+           File.open(dest_file, 'w') { |file| file.write(source_to_update) }
+        end
+
+        def directory(relative_path)
+          # logger.directory "#{destination_path(relative_path)}/"
+        end
+      end
+
+    end
+  end
+end