railties 3.0.0.beta4 → 3.0.0.rc

data/lib/rails/generators/rails/app/templates/public/javascripts/rails.js

@@ -1,87 +1,148 @@
-document.observe("dom:loaded", function() {
+(function() {
+  // Technique from Juriy Zaytsev
+  // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
+  function isEventSupported(eventName) {
+    var el = document.createElement('div');
+    eventName = 'on' + eventName;
+    var isSupported = (eventName in el);
+    if (!isSupported) {
+      el.setAttribute(eventName, 'return;');
+      isSupported = typeof el[eventName] == 'function';
+    }
+    el = null;
+    return isSupported;
+  }
+
+  function isForm(element) {
+    return Object.isElement(element) && element.nodeName.toUpperCase() == 'FORM'
+  }
+
+  function isInput(element) {
+    if (Object.isElement(element)) {
+      var name = element.nodeName.toUpperCase()
+      return name == 'INPUT' || name == 'SELECT' || name == 'TEXTAREA'
+    }
+    else return false
+  }
+
+  var submitBubbles = isEventSupported('submit'),
+      changeBubbles = isEventSupported('change')
+
+  if (!submitBubbles || !changeBubbles) {
+    // augment the Event.Handler class to observe custom events when needed
+    Event.Handler.prototype.initialize = Event.Handler.prototype.initialize.wrap(
+      function(init, element, eventName, selector, callback) {
+        init(element, eventName, selector, callback)
+        // is the handler being attached to an element that doesn't support this event?
+        if ( (!submitBubbles && this.eventName == 'submit' && !isForm(this.element)) ||
+             (!changeBubbles && this.eventName == 'change' && !isInput(this.element)) ) {
+          // "submit" => "emulated:submit"
+          this.eventName = 'emulated:' + this.eventName
+        }
+      }
+    )
+  }
+
+  if (!submitBubbles) {
+    // discover forms on the page by observing focus events which always bubble
+    document.on('focusin', 'form', function(focusEvent, form) {
+      // special handler for the real "submit" event (one-time operation)
+      if (!form.retrieve('emulated:submit')) {
+        form.on('submit', function(submitEvent) {
+          var emulated = form.fire('emulated:submit', submitEvent, true)
+          // if custom event received preventDefault, cancel the real one too
+          if (emulated.returnValue === false) submitEvent.preventDefault()
+        })
+        form.store('emulated:submit', true)
+      }
+    })
+  }
+
+  if (!changeBubbles) {
+    // discover form inputs on the page
+    document.on('focusin', 'input, select, texarea', function(focusEvent, input) {
+      // special handler for real "change" events
+      if (!input.retrieve('emulated:change')) {
+        input.on('change', function(changeEvent) {
+          input.fire('emulated:change', changeEvent, true)
+        })
+        input.store('emulated:change', true)
+      }
+    })
+  }
+
   function handleRemote(element) {
     var method, url, params;
 
+    var event = element.fire("ajax:before");
+    if (event.stopped) return false;
+
     if (element.tagName.toLowerCase() === 'form') {
       method = element.readAttribute('method') || 'post';
       url    = element.readAttribute('action');
-      params = element.serialize(true);
+      params = element.serialize();
     } else {
       method = element.readAttribute('data-method') || 'get';
       url    = element.readAttribute('href');
       params = {};
     }
 
-    var event = element.fire("ajax:before");
-    if (event.stopped) return false;
-
     new Ajax.Request(url, {
       method: method,
       parameters: params,
-      asynchronous: true,
       evalScripts: true,
 
-      onLoading:     function(request) { element.fire("ajax:loading", {request: request}); },
-      onLoaded:      function(request) { element.fire("ajax:loaded", {request: request}); },
-      onInteractive: function(request) { element.fire("ajax:interactive", {request: request}); },
-      onComplete:    function(request) { element.fire("ajax:complete", {request: request}); },
-      onSuccess:     function(request) { element.fire("ajax:success", {request: request}); },
-      onFailure:     function(request) { element.fire("ajax:failure", {request: request}); }
+      onComplete:    function(request) { element.fire("ajax:complete", request); },
+      onSuccess:     function(request) { element.fire("ajax:success",  request); },
+      onFailure:     function(request) { element.fire("ajax:failure",  request); }
     });
 
     element.fire("ajax:after");
   }
 
   function handleMethod(element) {
-    var method, url, token_name, token;
-
-    method     = element.readAttribute('data-method');
-    url        = element.readAttribute('href');
-    csrf_param = $$('meta[name=csrf-param]').first();
-    csrf_token = $$('meta[name=csrf-token]').first();
+    var method = element.readAttribute('data-method'),
+        url = element.readAttribute('href'),
+        csrf_param = $$('meta[name=csrf-param]')[0],
+        csrf_token = $$('meta[name=csrf-token]')[0];
 
     var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
-    element.parentNode.appendChild(form);
+    element.parentNode.insert(form);
 
-    if (method != 'post') {
+    if (method !== 'post') {
       var field = new Element('input', { type: 'hidden', name: '_method', value: method });
-      form.appendChild(field);
+      form.insert(field);
     }
 
     if (csrf_param) {
-      var param = csrf_param.readAttribute('content');
-      var token = csrf_token.readAttribute('content');
-      var field = new Element('input', { type: 'hidden', name: param, value: token });
-      form.appendChild(field);
+      var param = csrf_param.readAttribute('content'),
+          token = csrf_token.readAttribute('content'),
+          field = new Element('input', { type: 'hidden', name: param, value: token });
+      form.insert(field);
     }
 
     form.submit();
   }
 
-  $(document.body).observe("click", function(event) {
-    var message = event.findElement().readAttribute('data-confirm');
-    if (message && !confirm(message)) {
-      event.stop();
-      return false;
-    }
 
-    var element = event.findElement("a[data-remote]");
-    if (element) {
-      handleRemote(element);
-      event.stop();
-      return true;
-    }
+  document.on("click", "*[data-confirm]", function(event, element) {
+    var message = element.readAttribute('data-confirm');
+    if (!confirm(message)) event.stop();
+  });
 
-    var element = event.findElement("a[data-method]");
-    if (element) {
-      handleMethod(element);
-      event.stop();
-      return true;
-    }
+  document.on("click", "a[data-remote]", function(event, element) {
+    if (event.stopped) return;
+    handleRemote(element);
+    event.stop();
+  });
+
+  document.on("click", "a[data-method]", function(event, element) {
+    if (event.stopped) return;
+    handleMethod(element);
+    event.stop();
   });
 
-  // TODO: I don't think submit bubbles in IE
-  $(document.body).observe("submit", function(event) {
+  document.on("submit", function(event) {
     var element = event.findElement(),
         message = element.readAttribute('data-confirm');
     if (message && !confirm(message)) {
@@ -103,16 +164,12 @@ document.observe("dom:loaded", function() {
     }
   });
 
-  $(document.body).observe("ajax:after", function(event) {
-    var element = event.findElement();
-
-    if (element.tagName.toLowerCase() === 'form') {
-      var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
-      inputs.each(function(input) {
-        input.value = input.readAttribute('data-original-value');
-        input.writeAttribute('data-original-value', null);
-        input.disabled = false;
-      });
-    }
+  document.on("ajax:after", "form", function(event, element) {
+    var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
+    inputs.each(function(input) {
+      input.value = input.readAttribute('data-original-value');
+      input.removeAttribute('data-original-value');
+      input.disabled = false;
+    });
   });
-});
+})();

data/lib/rails/generators/rails/app/templates/test/test_helper.rb.tt

@@ -3,7 +3,7 @@ require File.expand_path('../../config/environment', __FILE__)
 require 'rails/test_help'
 
 class ActiveSupport::TestCase
-<% unless options[:skip_activerecord] -%>
+<% unless options[:skip_active_record] -%>
   # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
   #
   # Note: You'll currently still have to declare fixtures explicitly in integration tests

data/lib/rails/generators/rails/model/USAGE

@@ -40,6 +40,6 @@ Examples:
             Module:     app/models/admin.rb
             Model:      app/models/admin/account.rb
             Test:       test/unit/admin/account_test.rb
-            Fixtures:   test/fixtures/admin_accounts.yml
+            Fixtures:   test/fixtures/admin/accounts.yml
             Migration:  db/migrate/XXX_add_admin_accounts.rb
 

data/lib/rails/generators/rails/resource/resource_generator.rb

@@ -14,23 +14,13 @@ module Rails
       class_option :actions, :type => :array, :banner => "ACTION ACTION", :default => [],
                              :desc => "Actions for the resource controller"
 
-      class_option :singleton, :type => :boolean, :desc => "Supply to create a singleton controller"
-
       def add_resource_route
         return if options[:actions].present?
-        route "resource#{:s unless options[:singleton]} :#{pluralize?(file_name)}"
+        route_config =  class_path.collect{|namespace| "namespace :#{namespace} do " }.join(" ") 
+        route_config << "resources :#{file_name.pluralize}"
+        route_config << " end" * class_path.size 
+        route route_config
       end
-
-      protected
-
-        def pluralize?(name)
-          if options[:singleton]
-            name
-          else
-            name.pluralize
-          end
-        end
-
     end
   end
 end

data/lib/rails/generators/rails/scaffold_controller/scaffold_controller_generator.rb

@@ -10,8 +10,6 @@ module Rails
       class_option :orm, :banner => "NAME", :type => :string, :required => true,
                          :desc => "ORM to generate the controller for"
 
-      class_option :singleton, :type => :boolean, :desc => "Supply to create a singleton controller"
-
       def create_controller_files
         template 'controller.rb', File.join('app/controllers', class_path, "#{controller_file_name}_controller.rb")
       end

data/lib/rails/generators/rails/scaffold_controller/templates/controller.rb

@@ -1,53 +1,51 @@
 class <%= controller_class_name %>Controller < ApplicationController
-<% unless options[:singleton] -%>
-  # GET /<%= table_name %>
-  # GET /<%= table_name %>.xml
+  # GET <%= route_url %>
+  # GET <%= route_url %>.xml
   def index
-    @<%= table_name %> = <%= orm_class.all(class_name) %>
+    @<%= plural_table_name %> = <%= orm_class.all(class_name) %>
 
     respond_to do |format|
       format.html # index.html.erb
-      format.xml  { render :xml => @<%= table_name %> }
+      format.xml  { render :xml => @<%= plural_table_name %> }
     end
   end
-<% end -%>
 
-  # GET /<%= table_name %>/1
-  # GET /<%= table_name %>/1.xml
+  # GET <%= route_url %>/1
+  # GET <%= route_url %>/1.xml
   def show
-    @<%= file_name %> = <%= orm_class.find(class_name, "params[:id]") %>
+    @<%= singular_table_name %> = <%= orm_class.find(class_name, "params[:id]") %>
 
     respond_to do |format|
       format.html # show.html.erb
-      format.xml  { render :xml => @<%= file_name %> }
+      format.xml  { render :xml => @<%= singular_table_name %> }
     end
   end
 
-  # GET /<%= table_name %>/new
-  # GET /<%= table_name %>/new.xml
+  # GET <%= route_url %>/new
+  # GET <%= route_url %>/new.xml
   def new
-    @<%= file_name %> = <%= orm_class.build(class_name) %>
+    @<%= singular_table_name %> = <%= orm_class.build(class_name) %>
 
     respond_to do |format|
       format.html # new.html.erb
-      format.xml  { render :xml => @<%= file_name %> }
+      format.xml  { render :xml => @<%= singular_table_name %> }
     end
   end
 
-  # GET /<%= table_name %>/1/edit
+  # GET <%= route_url %>/1/edit
   def edit
-    @<%= file_name %> = <%= orm_class.find(class_name, "params[:id]") %>
+    @<%= singular_table_name %> = <%= orm_class.find(class_name, "params[:id]") %>
   end
 
-  # POST /<%= table_name %>
-  # POST /<%= table_name %>.xml
+  # POST <%= route_url %>
+  # POST <%= route_url %>.xml
   def create
-    @<%= file_name %> = <%= orm_class.build(class_name, "params[:#{file_name}]") %>
+    @<%= singular_table_name %> = <%= orm_class.build(class_name, "params[:#{singular_table_name}]") %>
 
     respond_to do |format|
       if @<%= orm_instance.save %>
-        format.html { redirect_to(@<%= file_name %>, :notice => '<%= human_name %> was successfully created.') }
-        format.xml  { render :xml => @<%= file_name %>, :status => :created, :location => @<%= file_name %> }
+        format.html { redirect_to(@<%= singular_table_name %>, :notice => '<%= human_name %> was successfully created.') }
+        format.xml  { render :xml => @<%= singular_table_name %>, :status => :created, :location => @<%= singular_table_name %> }
       else
         format.html { render :action => "new" }
         format.xml  { render :xml => @<%= orm_instance.errors %>, :status => :unprocessable_entity }
@@ -55,14 +53,14 @@ class <%= controller_class_name %>Controller < ApplicationController
     end
   end
 
-  # PUT /<%= table_name %>/1
-  # PUT /<%= table_name %>/1.xml
+  # PUT <%= route_url %>/1
+  # PUT <%= route_url %>/1.xml
   def update
-    @<%= file_name %> = <%= orm_class.find(class_name, "params[:id]") %>
+    @<%= singular_table_name %> = <%= orm_class.find(class_name, "params[:id]") %>
 
     respond_to do |format|
-      if @<%= orm_instance.update_attributes("params[:#{file_name}]") %>
-        format.html { redirect_to(@<%= file_name %>, :notice => '<%= human_name %> was successfully updated.') }
+      if @<%= orm_instance.update_attributes("params[:#{singular_table_name}]") %>
+        format.html { redirect_to(@<%= singular_table_name %>, :notice => '<%= human_name %> was successfully updated.') }
         format.xml  { head :ok }
       else
         format.html { render :action => "edit" }
@@ -71,14 +69,14 @@ class <%= controller_class_name %>Controller < ApplicationController
     end
   end
 
-  # DELETE /<%= table_name %>/1
-  # DELETE /<%= table_name %>/1.xml
+  # DELETE <%= route_url %>/1
+  # DELETE <%= route_url %>/1.xml
   def destroy
-    @<%= file_name %> = <%= orm_class.find(class_name, "params[:id]") %>
+    @<%= singular_table_name %> = <%= orm_class.find(class_name, "params[:id]") %>
     @<%= orm_instance.destroy %>
 
     respond_to do |format|
-      format.html { redirect_to(<%= table_name %>_url) }
+      format.html { redirect_to(<%= index_helper %>_url) }
       format.xml  { head :ok }
     end
   end

data/lib/rails/generators/resource_helpers.rb

@@ -72,7 +72,7 @@ module Rails
         end
 
         # Initialize ORM::Generators::ActiveModel to access instance methods.
-        def orm_instance(name=file_name)
+        def orm_instance(name=singular_table_name)
           @orm_instance ||= @orm_class.new(name)
         end
     end

data/lib/rails/generators/test_case.rb

@@ -51,7 +51,7 @@ module Rails
       # Sets default arguments on generator invocation. This can be overwritten when
       # invoking it.
       #
-      #   arguments %w(app_name --skip-activerecord)
+      #   arguments %w(app_name --skip-active-record)
       #
       def self.arguments(array)
         self.default_arguments = array
@@ -189,18 +189,23 @@ module Rails
       end
       alias :assert_method :assert_instance_method
 
-      # Asserts the given field name gets translated to an attribute type 
-      # properly.
+      # Asserts the given attribute type gets translated to a field type
+      # properly:
       #
       #   assert_field_type :date, :date_select
       #
-      def assert_field_type(name, attribute_type)
-        assert_equal(
-          Rails::Generators::GeneratedAttribute.new('test', name.to_s).field_type,
-          attribute_type
-        )
+      def assert_field_type(attribute_type, field_type)
+        assert_equal(field_type, create_generated_attribute(attribute_type).field_type)
       end
-      
+
+      # Asserts the given attribute type gets a proper default value:
+      #
+      #   assert_field_type :string, "MyString"
+      #
+      def assert_field_default_value(attribute_type, value)
+        assert_equal(value, create_generated_attribute(attribute_type).default)
+      end
+
       # Runs the generator configured for this class. The first argument is an array like
       # command line arguments:
       #
@@ -209,8 +214,8 @@ module Rails
       #     destination File.expand_path("../tmp", File.dirname(__FILE__))
       #     teardown :cleanup_destination_root
       #
-      #     test "database.yml is not created when skipping activerecord" do
-      #       run_generator %w(myapp --skip-activerecord)
+      #     test "database.yml is not created when skipping Active Record" do
+      #       run_generator %w(myapp --skip-active-record)
       #       assert_no_file "config/database.yml"
       #     end
       #   end
@@ -226,6 +231,15 @@ module Rails
         @generator ||= self.generator_class.new(args, options, config.reverse_merge(:destination_root => destination_root))
       end
 
+      # Create a Rails::Generators::GeneratedAttribute by supplying the
+      # attribute type and, optionally, the attribute name:
+      #
+      #   create_generated_attribute(:string, 'name')
+      #
+      def create_generated_attribute(attribute_type, name = 'test')
+        Rails::Generators::GeneratedAttribute.new(name, attribute_type.to_s)
+      end
+
       protected
 
         def destination_root_is_set? #:nodoc: