tabulous 0.0.1

data/test/applications/simple_tabs/public/javascripts/rails.js

@@ -0,0 +1,175 @@
+(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();
+    } else {
+      method = element.readAttribute('data-method') || 'get';
+      url    = element.readAttribute('href');
+      params = {};
+    }
+
+    new Ajax.Request(url, {
+      method: method,
+      parameters: params,
+      evalScripts: true,
+
+      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 = 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.insert(form);
+
+    if (method !== 'post') {
+      var field = new Element('input', { type: 'hidden', name: '_method', value: method });
+      form.insert(field);
+    }
+
+    if (csrf_param) {
+      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.on("click", "*[data-confirm]", function(event, element) {
+    var message = element.readAttribute('data-confirm');
+    if (!confirm(message)) event.stop();
+  });
+
+  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();
+  });
+
+  document.on("submit", function(event) {
+    var element = event.findElement(),
+        message = element.readAttribute('data-confirm');
+    if (message && !confirm(message)) {
+      event.stop();
+      return false;
+    }
+
+    var inputs = element.select("input[type=submit][data-disable-with]");
+    inputs.each(function(input) {
+      input.disabled = true;
+      input.writeAttribute('data-original-value', input.value);
+      input.value = input.readAttribute('data-disable-with');
+    });
+
+    var element = event.findElement("form[data-remote]");
+    if (element) {
+      handleRemote(element);
+      event.stop();
+    }
+  });
+
+  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/test/applications/simple_tabs/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/test/applications/simple_tabs/test/integration/simple_tabs_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path("../integration_test_helper", File.dirname(__FILE__))
+ 
+class SimpleTabsTest < ActionController::IntegrationTest
+ 
+  test "viewing simple tabs" do
+    visit '/'
+    assert page.has_content?('This tests the most basic usage of tabulous.')
+  end
+ 
+  test "clicking galaxies tab" do
+    visit '/'
+    click_link 'Galaxies'
+    assert page.has_content?('Listing galaxies')
+    assert page.has_no_content?('Listing stars')
+    assert page.has_no_content?('Listing planets')
+  end
+ 
+  test "clicking stars tab" do
+    visit '/'
+    click_link 'Stars'
+    assert page.has_content?('Listing stars')
+    assert page.has_no_content?('Listing galaxies')
+    assert page.has_no_content?('Listing planets')
+  end
+ 
+  test "clicking planets tab" do
+    visit '/'
+    click_link 'Planets'
+    assert page.has_content?('Listing planets')
+    assert page.has_no_content?('Listing stars')
+    assert page.has_no_content?('Listing galaxies')
+  end
+ 
+end

data/test/applications/simple_tabs/test/integration_test_helper.rb

@@ -0,0 +1,6 @@
+require File.expand_path('test_helper', File.dirname(__FILE__))
+require File.expand_path('../../../test_application_integration_test_helper', File.dirname(__FILE__))
+
+# This file contains integration test code specific to this test application.  Integration
+# test code that is shared among all test applications should live in
+# test/test_application_integration_test_helper.rb.

data/test/applications/simple_tabs/test/test_helper.rb

@@ -0,0 +1,8 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+require File.expand_path('../../../test_application_test_helper', File.dirname(__FILE__))
+
+# This file contains test code specific to this test application.  Helper
+# test code that is shared among all test applications should live in
+# test/test_application_test_helper.rb.

data/test/applications/subtabs/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+log/*.log
+tmp/

data/test/applications/subtabs/Gemfile

@@ -0,0 +1,7 @@
+source :rubygems
+
+# Do not add gems directly to this file.  Add them to the test/test_application_gemfile
+# instead and they will be automatically loaded in.
+
+require File.expand_path('../../test_application_gemfile', File.dirname(__FILE__))
+shared_test_application_gems(self)

data/test/applications/subtabs/Rakefile

@@ -0,0 +1,7 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+require 'rake'
+
+Subtabs::Application.load_tasks

data/test/applications/subtabs/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+end

data/test/applications/subtabs/app/controllers/exoplanets_controller.rb

@@ -0,0 +1,83 @@
+class ExoplanetsController < ApplicationController
+  # GET /exoplanets
+  # GET /exoplanets.xml
+  def index
+    @exoplanets = Exoplanet.all
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml => @exoplanets }
+    end
+  end
+
+  # GET /exoplanets/1
+  # GET /exoplanets/1.xml
+  def show
+    @exoplanet = Exoplanet.find(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.xml  { render :xml => @exoplanet }
+    end
+  end
+
+  # GET /exoplanets/new
+  # GET /exoplanets/new.xml
+  def new
+    @exoplanet = Exoplanet.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.xml  { render :xml => @exoplanet }
+    end
+  end
+
+  # GET /exoplanets/1/edit
+  def edit
+    @exoplanet = Exoplanet.find(params[:id])
+  end
+
+  # POST /exoplanets
+  # POST /exoplanets.xml
+  def create
+    @exoplanet = Exoplanet.new(params[:exoplanet])
+
+    respond_to do |format|
+      if @exoplanet.save
+        format.html { redirect_to(@exoplanet, :notice => 'Exoplanet was successfully created.') }
+        format.xml  { render :xml => @exoplanet, :status => :created, :location => @exoplanet }
+      else
+        format.html { render :action => "new" }
+        format.xml  { render :xml => @exoplanet.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /exoplanets/1
+  # PUT /exoplanets/1.xml
+  def update
+    @exoplanet = Exoplanet.find(params[:id])
+
+    respond_to do |format|
+      if @exoplanet.update_attributes(params[:exoplanet])
+        format.html { redirect_to(@exoplanet, :notice => 'Exoplanet was successfully updated.') }
+        format.xml  { head :ok }
+      else
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @exoplanet.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /exoplanets/1
+  # DELETE /exoplanets/1.xml
+  def destroy
+    @exoplanet = Exoplanet.find(params[:id])
+    @exoplanet.destroy
+
+    respond_to do |format|
+      format.html { redirect_to(exoplanets_url) }
+      format.xml  { head :ok }
+    end
+  end
+end

data/test/applications/subtabs/app/controllers/galaxies/elliptical_galaxies_controller.rb

@@ -0,0 +1,85 @@
+module Galaxies
+  class EllipticalGalaxiesController < ApplicationController
+    # GET /elliptical_galaxies
+    # GET /elliptical_galaxies.xml
+    def index
+      @elliptical_galaxies = EllipticalGalaxy.all
+
+      respond_to do |format|
+        format.html # index.html.erb
+        format.xml  { render :xml => @elliptical_galaxies }
+      end
+    end
+
+    # GET /elliptical_galaxies/1
+    # GET /elliptical_galaxies/1.xml
+    def show
+      @elliptical_galaxy = EllipticalGalaxy.find(params[:id])
+
+      respond_to do |format|
+        format.html # show.html.erb
+        format.xml  { render :xml => @elliptical_galaxy }
+      end
+    end
+
+    # GET /elliptical_galaxies/new
+    # GET /elliptical_galaxies/new.xml
+    def new
+      @elliptical_galaxy = EllipticalGalaxy.new
+
+      respond_to do |format|
+        format.html # new.html.erb
+        format.xml  { render :xml => @elliptical_galaxy }
+      end
+    end
+
+    # GET /elliptical_galaxies/1/edit
+    def edit
+      @elliptical_galaxy = EllipticalGalaxy.find(params[:id])
+    end
+
+    # POST /elliptical_galaxies
+    # POST /elliptical_galaxies.xml
+    def create
+      @elliptical_galaxy = EllipticalGalaxy.new(params[:elliptical_galaxy])
+
+      respond_to do |format|
+        if @elliptical_galaxy.save
+          format.html { redirect_to(galaxies_elliptical_galaxy_path(@elliptical_galaxy), :notice => 'Elliptical galaxy was successfully created.') }
+          format.xml  { render :xml => @elliptical_galaxy, :status => :created, :location => @elliptical_galaxy }
+        else
+          format.html { render :action => "new" }
+          format.xml  { render :xml => @elliptical_galaxy.errors, :status => :unprocessable_entity }
+        end
+      end
+    end
+
+    # PUT /elliptical_galaxies/1
+    # PUT /elliptical_galaxies/1.xml
+    def update
+      @elliptical_galaxy = EllipticalGalaxy.find(params[:id])
+
+      respond_to do |format|
+        if @elliptical_galaxy.update_attributes(params[:elliptical_galaxy])
+          format.html { redirect_to(galaxies_elliptical_galaxy_path(@elliptical_galaxy), :notice => 'Elliptical galaxy was successfully updated.') }
+          format.xml  { head :ok }
+        else
+          format.html { render :action => "edit" }
+          format.xml  { render :xml => @elliptical_galaxy.errors, :status => :unprocessable_entity }
+        end
+      end
+    end
+
+    # DELETE /elliptical_galaxies/1
+    # DELETE /elliptical_galaxies/1.xml
+    def destroy
+      @elliptical_galaxy = EllipticalGalaxy.find(params[:id])
+      @elliptical_galaxy.destroy
+
+      respond_to do |format|
+        format.html { redirect_to(galaxies_elliptical_galaxies_url) }
+        format.xml  { head :ok }
+      end
+    end
+  end
+end

data/test/applications/subtabs/app/controllers/galaxies/lenticular_galaxies_controller.rb

@@ -0,0 +1,85 @@
+module Galaxies
+  class LenticularGalaxiesController < ApplicationController
+    # GET /lenticular_galaxies
+    # GET /lenticular_galaxies.xml
+    def index
+      @lenticular_galaxies = LenticularGalaxy.all
+
+      respond_to do |format|
+        format.html # index.html.erb
+        format.xml  { render :xml => @lenticular_galaxies }
+      end
+    end
+
+    # GET /lenticular_galaxies/1
+    # GET /lenticular_galaxies/1.xml
+    def show
+      @lenticular_galaxy = LenticularGalaxy.find(params[:id])
+
+      respond_to do |format|
+        format.html # show.html.erb
+        format.xml  { render :xml => @lenticular_galaxy }
+      end
+    end
+
+    # GET /lenticular_galaxies/new
+    # GET /lenticular_galaxies/new.xml
+    def new
+      @lenticular_galaxy = LenticularGalaxy.new
+
+      respond_to do |format|
+        format.html # new.html.erb
+        format.xml  { render :xml => @lenticular_galaxy }
+      end
+    end
+
+    # GET /lenticular_galaxies/1/edit
+    def edit
+      @lenticular_galaxy = LenticularGalaxy.find(params[:id])
+    end
+
+    # POST /lenticular_galaxies
+    # POST /lenticular_galaxies.xml
+    def create
+      @lenticular_galaxy = LenticularGalaxy.new(params[:lenticular_galaxy])
+
+      respond_to do |format|
+        if @lenticular_galaxy.save
+          format.html { redirect_to(galaxies_lenticular_galaxy_path(@lenticular_galaxy), :notice => 'Lenticular galaxy was successfully created.') }
+          format.xml  { render :xml => @lenticular_galaxy, :status => :created, :location => @lenticular_galaxy }
+        else
+          format.html { render :action => "new" }
+          format.xml  { render :xml => @lenticular_galaxy.errors, :status => :unprocessable_entity }
+        end
+      end
+    end
+
+    # PUT /lenticular_galaxies/1
+    # PUT /lenticular_galaxies/1.xml
+    def update
+      @lenticular_galaxy = LenticularGalaxy.find(params[:id])
+
+      respond_to do |format|
+        if @lenticular_galaxy.update_attributes(params[:lenticular_galaxy])
+          format.html { redirect_to(galaxies_lenticular_galaxy_path(@lenticular_galaxy), :notice => 'Lenticular galaxy was successfully updated.') }
+          format.xml  { head :ok }
+        else
+          format.html { render :action => "edit" }
+          format.xml  { render :xml => @lenticular_galaxy.errors, :status => :unprocessable_entity }
+        end
+      end
+    end
+
+    # DELETE /lenticular_galaxies/1
+    # DELETE /lenticular_galaxies/1.xml
+    def destroy
+      @lenticular_galaxy = LenticularGalaxy.find(params[:id])
+      @lenticular_galaxy.destroy
+
+      respond_to do |format|
+        format.html { redirect_to(galaxies_lenticular_galaxies_url) }
+        format.xml  { head :ok }
+      end
+    end
+  end
+end