rails_product 0.5

data/lib/rails_generator/base.rb

@@ -0,0 +1,203 @@
+require File.dirname(__FILE__) + '/options'
+require File.dirname(__FILE__) + '/manifest'
+require File.dirname(__FILE__) + '/spec'
+
+# 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 or
+# tarballs for inclusion system-wide, per-user, or per-application.
+#
+# Generators may subclass other generators to provide variations that
+# require little or no new logic but replace the template files.
+# The postback generator is an example:  it subclasses the scaffold
+# generator and just replaces the code templates with its own.
+#
+# Now go forth and multiply^Wgenerate.
+module Rails
+  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.
+    # You're probably looking for NamedBase, a subclass meant for generating
+    # "named" components such as models, controllers, and mailers.
+    #
+    # Generators create a manifest of the actions they perform then hand
+    # the manifest to a command which replay the actions to do the heavy
+    # lifting.  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 EliteGenerator < Rails::Generator::Base
+    #     def manifest
+    #       record do |m|
+    #         m.do(some)
+    #         m.things(in) { here }
+    #       end
+    #     end
+    #   end
+    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 for controller and
+    # mailer convenience.
+    #
+    # 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.
+    #
+    # See Rails::Generator::Base for a discussion of Manifests and Commands.
+    class NamedBase < Base
+      attr_reader   :name, :class_name, :singular_name, :plural_name
+      attr_reader   :class_path, :file_path, :class_nesting, :class_nesting_depth
+      alias_method  :file_name,  :singular_name
+      alias_method  :table_name, :plural_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
+
+      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)
+          if @class_nesting.empty?
+            @class_name = @class_name_without_nesting
+          else
+            @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/lib/rails_generator/commands.rb

@@ -0,0 +1,409 @@
+require 'delegate'
+require 'optparse'
+require 'fileutils'
+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.append_features(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
+
+        private
+          # Ask the user interactively whether to force collision.
+          def force_file_collision?(destination)
+            $stdout.print "overwrite #{destination}? [Ynaq] "
+            case $stdin.gets
+              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 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 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'
+        #
+        # 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 = {})
+          # Determine full paths for source and destination files.
+          source      = source_path(relative_source)
+          destination = destination_path(relative_destination)
+
+          # Check for and resolve file collisions.
+          if File.exists?(destination)
+
+            # Make a choice whether to overwrite the file.  :force and
+            # :skip already have their mind made up, but give :ask a shot.
+            choice = case options[:collision].to_sym #|| :ask
+              when :ask   then force_file_collision?(relative_destination)
+              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, 'w') do |df|
+            File.open(source) do |sf|
+              if block_given?
+                df.write(yield(sf))
+              else
+                line = sf.gets
+                if file_options[:shebang]
+                  df.puts("#!#{file_options[:shebang]}")
+                  df.puts(line) if line !~ /^#!/
+                else
+                  df.puts(line)
+                end
+                df.write(sf.read)
+              end
+            end
+          end
+
+          # Optionally change permissions.
+          if file_options[:chmod]
+            FileUtils.chmod(file_options[:chmod], destination)
+          end
+        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
+            FileUtils.mkdir_p(path) unless options[:pretend]
+          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
+
+        private
+          # 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, options = {})
+          destination = destination_path(relative_destination)
+          if File.exists?(destination)
+            logger.rm relative_destination
+            FileUtils.rm(destination) unless options[:pretend]
+          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
+                FileUtils.rmdir(path) unless options[:pretend]
+              else
+                logger.notempty partial
+              end
+            else
+              logger.missing partial
+            end
+            parts.pop
+          end
+        end
+
+        def complex_template(*args)
+          # nothing should be done here
+        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
+      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

data/lib/rails_generator/generators/applications/app/USAGE

@@ -0,0 +1,16 @@
+Description:
+    The 'rails' command creates a new Rails application with a default
+    directory structure and configuration at the path you specify.
+
+Example:
+    rails ~/Code/Ruby/weblog
+
+    This generates a skeletal Rails installation in ~/Code/Ruby/weblog.
+    See the README in the newly created application to get going.
+
+WARNING:
+    Only specify --without-gems if you did not use gems to install Rails.
+    Your application will expect to find activerecord, actionpack, and
+    actionmailer directories in the vendor directory.  A popular way to track
+    the bleeding edge of Rails development is to checkout from source control
+    directly to the vendor directory.  See http://dev.rubyonrails.com