RubyGems - rails - Versions diffs - 0.9.5 → 0.10.0 - Mend

rails 0.9.5 → 0.10.0

Potentially problematic release.

This version of rails might be problematic. Click here for more details.

Files changed (77) hide show

data/{generators → lib/rails_generator/generators/components}/scaffold/templates/controller.rb RENAMED

@@ -1,4 +1,4 @@
-class <%= @controller_class_name %>Controller < ApplicationController
+class <%= controller_class_name %>Controller < ApplicationController
 <% unless suffix -%>
   def index
     list

data/lib/rails_generator/generators/components/scaffold/templates/form.rhtml ADDED

@@ -0,0 +1,5 @@
+<%%= start_form_tag :action => '<%= @form_action %><%= @suffix %>' %>
+<%%= hidden_field '<%= @singular_name %>', 'id' %>
+<%= all_input_tags(@model_instance, @singular_name, {}) %>
+<input type="submit" value="<%= @form_action.to_s.capitalize %>" />
+<%%= end_form_tag %>

data/{generators → lib/rails_generator/generators/components}/scaffold/templates/functional_test.rb RENAMED

@@ -1,15 +1,16 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require '<%= @controller_name %>_controller'
+require File.dirname(__FILE__) + '<%= '/..' * controller_class_nesting_depth %>/../test_helper'
+require '<%= controller_file_path %>_controller'
 # Re-raise errors caught by the controller.
-class <%= @controller_class_name %>Controller; def rescue_action(e) raise e end; end
+class <%= controller_class_name %>Controller; def rescue_action(e) raise e end; end
-class <%= @controller_class_name %>ControllerTest < Test::Unit::TestCase
+class <%= controller_class_name %>ControllerTest < Test::Unit::TestCase
   fixtures :<%= table_name %>
   def setup
-    @controller = <%= @controller_class_name %>Controller.new
-    @request, @response = ActionController::TestRequest.new, ActionController::TestResponse.new
+    @controller = <%= controller_class_name %>Controller.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
   end
 <% for action in unscaffolded_actions -%>

data/lib/rails_generator/generators/components/scaffold/templates/helper.rb ADDED

	@@ -0,0 +1,2 @@
1	+ module <%= controller_class_name %>Helper
2	+ end

data/{generators → lib/rails_generator/generators/components}/scaffold/templates/layout.rhtml RENAMED

@@ -1,6 +1,6 @@
 <html>
 <head>
-  <title>Scaffolding: <%%= controller.controller_name %>#<%%= controller.action_name %></title>
+  <title><%= controller_class_name %>: <%%= controller.action_name %></title>
   <link href="/stylesheets/scaffold.css" rel="stylesheet" type="text/css" />
 </head>
 <body>

data/{generators → lib/rails_generator/generators/components}/scaffold/templates/style.css RENAMED

@@ -24,30 +24,30 @@ a:hover { color: #fff; background-color:#000; }
 #ErrorExplanation {
   width: 400px;
-	border: 2px solid #red;
-	padding: 7px;
-	padding-bottom: 12px;
-	margin-bottom: 20px;
-	background-color: #f0f0f0;
+  border: 2px solid #red;
+  padding: 7px;
+  padding-bottom: 12px;
+  margin-bottom: 20px;
+  background-color: #f0f0f0;
 }
 #ErrorExplanation h2 {
-	text-align: left;
-	font-weight: bold;
-	padding: 5px 5px 5px 15px;
-	font-size: 12px;
-	margin: -7px;
-	background-color: #c00;
-	color: #fff;
+  text-align: left;
+  font-weight: bold;
+  padding: 5px 5px 5px 15px;
+  font-size: 12px;
+  margin: -7px;
+  background-color: #c00;
+  color: #fff;
 }
 #ErrorExplanation p {
-	color: #333;
-	margin-bottom: 0;
-	padding: 5px;
+  color: #333;
+  margin-bottom: 0;
+  padding: 5px;
 }
 #ErrorExplanation ul li {
-	font-size: 12px;
-	list-style: square;
+  font-size: 12px;
+  list-style: square;
 }

data/{generators → lib/rails_generator/generators/components}/scaffold/templates/view_edit.rhtml RENAMED

@@ -1,7 +1,7 @@
 <h1>Editing <%= singular_name %></h1>
 <%%= error_messages_for '<%= singular_name %>' %>
-<%%= form '<%= singular_name %>', :action => 'update<%= suffix %>' %>
+<%= template_for_inclusion %>
 <%%= link_to 'Show', :action => 'show<%= suffix %>', :id => @<%= singular_name %>.id %> |
 <%%= link_to 'Back', :action => 'list<%= suffix %>' %>

data/{generators → lib/rails_generator/generators/components}/scaffold/templates/view_list.rhtml RENAMED

@@ -10,7 +10,7 @@
 <%% for <%= singular_name %> in @<%= plural_name %> %>
   <tr>
   <%% for column in <%= class_name %>.content_columns %>
-    <td><%%=h <%= singular_name %>[column.name] %></td>
+    <td><%%=h <%= singular_name %>.send(column.name) %></td>
   <%% end %>
     <td><%%= link_to 'Show', :action => 'show<%= suffix %>', :id => <%= singular_name %>.id %></td>
     <td><%%= link_to 'Edit', :action => 'edit<%= suffix %>', :id => <%= singular_name %>.id %></td>

data/{generators → lib/rails_generator/generators/components}/scaffold/templates/view_new.rhtml RENAMED

@@ -1,6 +1,6 @@
 <h1>New <%= @singular_name %></h1>
 <%%= error_messages_for '<%= singular_name %>' %>
-<%%= form '<%= singular_name %>', :action => 'create<%= suffix %>' %>
+<%= template_for_inclusion %>
 <%%= link_to 'Back', :action => 'list<%= suffix %>' %>

data/{generators → lib/rails_generator/generators/components}/scaffold/templates/view_show.rhtml RENAMED

File without changes

data/lib/rails_generator/lookup.rb ADDED

@@ -0,0 +1,200 @@
+require File.dirname(__FILE__) + '/spec'
+class Object
+  class << self
+    # Lookup missing generators using const_missing.  This allows any
+    # generator to reference another without having to know its location:
+    # RubyGems, ~/.rails/generators, and RAILS_ROOT/script/generators.
+    def lookup_missing_generator(class_id)
+      if md = /(.+)Generator$/.match(class_id.to_s)
+        name = md.captures.first.demodulize.underscore
+        Rails::Generator::Base.lookup(name).klass
+      else
+        const_missing_before_generators(class_id)
+      end
+    end
+    unless respond_to?(:const_missing_before_generators)
+      alias_method :const_missing_before_generators, :const_missing
+      alias_method :const_missing, :lookup_missing_generator
+    end
+  end
+end
+# User home directory lookup adapted from RubyGems.
+def Dir.user_home
+  if ENV['HOME']
+    ENV['HOME']
+  elsif ENV['USERPROFILE']
+    ENV['USERPROFILE']
+  elsif ENV['HOMEDRIVE'] and ENV['HOMEPATH']
+    "#{ENV['HOMEDRIVE']}:#{ENV['HOMEPATH']}"
+  else
+    File.expand_path '~'
+  end
+end
+module Rails
+  module Generator
+    # Generator lookup is managed by a list of sources which return specs
+    # describing where to find and how to create generators.  This module
+    # provides class methods for manipulating the source list and looking up
+    # generator specs, and an #instance wrapper for quickly instantiating
+    # generators by name.
+    #
+    # A spec is not a generator:  it's a description of where to find
+    # the generator and how to create it.  A source is anything that
+    # yields generators from #each.  PathSource and GemSource are provided.
+    module Lookup
+      def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+        base.use_component_sources!
+      end
+      # Convenience method to instantiate another generator.
+      def instance(generator_name, args, runtime_options = {})
+        self.class.instance(generator_name, args, runtime_options)
+      end
+      module ClassMethods
+        # The list of sources where we look, in order, for generators.
+        def sources
+          read_inheritable_attribute(:sources) or use_component_sources!
+        end
+        # Add a source to the end of the list.
+        def append_sources(*args)
+          sources.concat(args.flatten)
+          invalidate_cache!
+        end
+        # Add a source to the beginning of the list.
+        def prepend_sources(*args)
+          write_inheritable_array(:sources, args.flatten + sources)
+          invalidate_cache!
+        end
+        # Reset the source list.
+        def reset_sources
+          write_inheritable_attribute(:sources, [])
+          invalidate_cache!
+        end
+        # Use application generators (app, ?).
+        def use_application_sources!
+          reset_sources
+          sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generators/applications")
+        end
+        # Use component generators (model, controller, etc).
+        # 1.  Rails application.  If RAILS_ROOT is defined we know we're
+        #     generating in the context of a Rails application, so search
+        #     RAILS_ROOT/script/generators.
+        # 2.  User home directory.  Search ~/.rails/generators.
+        # 3.  RubyGems.  Search for gems named *_generator.
+        # 4.  Builtins.  Model, controller, mailer, scaffold.
+        def use_component_sources!
+          reset_sources
+          sources << PathSource.new(:app, "#{::RAILS_ROOT}/script/generators") if defined? ::RAILS_ROOT
+          sources << PathSource.new(:user, "#{Dir.user_home}/.rails/generators")
+          sources << GemSource.new if Object.const_defined?(:Gem)
+          sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generators/components")
+        end
+        # Lookup knows how to find generators' Specs from a list of Sources.
+        # Searches the sources, in order, for the first matching name.
+        def lookup(generator_name)
+          @found ||= {}
+          generator_name = generator_name.to_s.downcase
+          @found[generator_name] ||= cache.find { |spec|
+            spec.name == generator_name
+          } or raise GeneratorError, "Couldn't find '#{generator_name}' generator"
+        end
+        # Convenience method to lookup and instantiate a generator.
+        def instance(generator_name, args = [], runtime_options = {})
+          lookup(generator_name).klass.new(args, full_options(runtime_options))
+        end
+        private
+          # Lookup and cache every generator from the source list.
+          def cache
+            @cache ||= sources.inject([]) { |cache, source| cache + source.map }
+          end
+          # Clear the cache whenever the source list changes.
+          def invalidate_cache!
+            @cache = nil
+          end
+      end
+    end
+    # Sources enumerate (yield from #each) generator specs which describe
+    # where to find and how to create generators.  Enumerable is mixed in so,
+    # for example, source.collect will retrieve every generator.
+    # Sources may be assigned a label to distinguish them.
+    class Source
+      include Enumerable
+      attr_reader :label
+      def initialize(label)
+        @label = label
+      end
+      # The each method must be implemented in subclasses.
+      # The base implementation raises an error.
+      def each
+        raise NotImplementedError
+      end
+      # Return a convenient sorted list of all generator names.
+      def names
+        map { |spec| spec.name }.sort
+      end
+    end
+    # PathSource looks for generators in a filesystem directory.
+    class PathSource < Source
+      attr_reader :path
+      def initialize(label, path)
+        super label
+        @path = path
+      end
+      # Yield each eligible subdirectory.
+      def each
+        Dir["#{path}/[a-z]*"].each do |dir|
+          if File.directory?(dir)
+            yield Spec.new(File.basename(dir), dir, label)
+          end
+        end
+      end
+    end
+    # GemSource hits the mines to quarry for generators.  The latest versions
+    # of gems named *_generator are selected.
+    class GemSource < Source
+      def initialize
+        super :RubyGems
+      end
+      # Yield latest versions of generator gems.
+      def each
+        Gem::cache.search(/_generator$/).inject({}) { |latest, gem|
+          hem = latest[gem.name]
+          latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+          latest
+        }.values.each { |gem|
+          yield Spec.new(gem.name.sub(/_generator$/, ''), gem.full_gem_path, label)
+        }
+      end
+    end
+  end
+end

data/lib/rails_generator/manifest.rb ADDED

@@ -0,0 +1,53 @@
+module Rails
+  module Generator
+    # Manifest captures the actions a generator performs.  Instantiate
+    # a manifest with an optional target object, hammer it with actions,
+    # then replay or rewind on the object of your choice.
+    #
+    # Example:
+    #   manifest = Manifest.new { |m|
+    #     m.make_directory '/foo'
+    #     m.create_file '/foo/bar.txt'
+    #   }
+    #   manifest.replay(creator)
+    #   manifest.rewind(destroyer)
+    class Manifest
+      attr_reader :target
+      # Take a default action target.  Yield self if block given.
+      def initialize(target = nil)
+        @target, @actions = target, []
+        yield self if block_given?
+      end
+      # Record an action.
+      def method_missing(action, *args, &block)
+        @actions << [action, args, block]
+      end
+      # Replay recorded actions.
+      def replay(target = nil)
+        send_actions(target || @target, @actions)
+      end
+      # Rewind recorded actions.
+      def rewind(target = nil)
+        send_actions(target || @target, @actions.reverse)
+      end
+      # Erase recorded actions.
+      def erase
+        @actions = []
+      end
+      private
+        def send_actions(target, actions)
+          actions.each do |method, args, block|
+            target.send(method, *args, &block)
+          end
+        end
+    end
+  end
+end

data/lib/rails_generator/options.rb ADDED

@@ -0,0 +1,134 @@
+require 'optparse'
+module Rails
+  module Generator
+    module Options
+      def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+        class << base
+          if respond_to?(:inherited)
+            alias_method :inherited_without_options, :inherited
+          end
+          alias_method :inherited, :inherited_with_options
+        end
+      end
+      module ClassMethods
+        def inherited_with_options(sub)
+          inherited_without_options(sub) if respond_to?(:inherited_without_options)
+          sub.extend(Rails::Generator::Options::ClassMethods)
+        end
+        def mandatory_options(options = nil)
+          if options
+            write_inheritable_attribute(:mandatory_options, options)
+          else
+            read_inheritable_attribute(:mandatory_options) or write_inheritable_attribute(:mandatory_options, {})
+          end
+        end
+        def default_options(options = nil)
+          if options
+            write_inheritable_attribute(:default_options, options)
+          else
+            read_inheritable_attribute(:default_options) or write_inheritable_attribute(:default_options, {})
+          end
+        end
+        # Merge together our class options.  In increasing precedence:
+        #   default_options   (class default options)
+        #   runtime_options   (provided as argument)
+        #   mandatory_options (class mandatory options)
+        def full_options(runtime_options = {})
+          default_options.merge(runtime_options).merge(mandatory_options)
+        end
+      end
+      # Each instance has an options hash that's populated by #parse.
+      def options
+        @options ||= {}
+      end
+      attr_writer :options
+      protected
+        # Convenient access to class mandatory options.
+        def mandatory_options
+          self.class.mandatory_options
+        end
+        # Convenient access to class default options.
+        def default_options
+          self.class.default_options
+        end
+        # Merge together our instance options.  In increasing precedence:
+        #   default_options   (class default options)
+        #   options           (instance options)
+        #   runtime_options   (provided as argument)
+        #   mandatory_options (class mandatory options)
+        def full_options(runtime_options = {})
+          self.class.full_options(options.merge(runtime_options))
+        end
+        # Parse arguments into the options hash.  Classes may customize
+        # parsing behavior by overriding these methods:
+        #   #banner                 Usage: ./script/generate [options]
+        #   #add_options!           Options:
+        #                             some options..
+        #   #add_general_options!   General Options:
+        #                             general options..
+        def parse!(args, runtime_options = {})
+          self.options = {}
+          @option_parser = OptionParser.new do |opt|
+            opt.banner = banner
+            add_options!(opt)
+            add_general_options!(opt)
+            opt.parse!(args)
+          end
+          return args
+        ensure
+          self.options = full_options(runtime_options)
+        end
+        # Raise a usage error.  Override usage_message to provide a blurb
+        # after the option parser summary.
+        def usage
+          raise UsageError, "#{@option_parser}\n#{usage_message}"
+        end
+        def usage_message
+          ''
+        end
+        # Override with your own usage banner.
+        def banner
+          "Usage: #{$0} [options]"
+        end
+        # Override to add your options to the parser:
+        #   def add_options!(opt)
+        #     opt.on('-v', '--verbose') { |value| options[:verbose] = value }
+        #   end
+        def add_options!(opt)
+        end
+        # Adds general options like -h and --quiet.  Usually don't override.
+        def add_general_options!(opt)
+          opt.separator ''
+          opt.separator 'General Options:'
+          opt.on('-p', '--pretend', 'Run but do not make any changes.') { |options[:pretend]| }
+          opt.on('-f', '--force', 'Overwrite files that already exist.') { options[:collision] = :force }
+          opt.on('-s', '--skip', 'Skip files that already exist.') { options[:collision] = :skip }
+          opt.on('-q', '--quiet', 'Keep is like a secret with /dev/null.') { |options[:quiet]| }
+          opt.on('-t', '--backtrace', 'Debugging: show backtrace on errors.') { |options[:backtrace]| }
+          opt.on('-h', '--help', 'Show this help message.') { |options[:help]| }
+        end
+    end
+  end
+end