funky_tabs 0.1.1

data/Manifest

@@ -0,0 +1,19 @@
+CHANGELOG
+Manifest
+README.rdoc
+Rakefile
+app/controllers/funky_tabs/update_controller.rb
+app/views/funky_tabs/update/_ajax.js.erb
+app/views/funky_tabs/update/_render_funky_tabs.html.erb
+app/views/funky_tabs/update/missing_tab.html.erb
+app/views/funky_tabs/update/update_tab.html.erb
+config/routes.rb
+funky_tabs.gemspec
+init.rb
+lib/funky_tabs.rb
+lib/funky_tabs/helpers.rb
+lib/funky_tabs/rails.rb
+lib/funky_tabs/renderers.rb
+lib/funky_tabs/tab.rb
+lib/funky_tabs/tab_action.rb
+test/funky_tabs_test.rb

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('funky_tabs', '0.1.1') do |p|
+  p.description    = "Create Ajaxified tabs with simple history through window location hashes for Rails."
+  p.url            = "http://github.com/thomaspouncy/funky_tabs"
+  p.author         = "Thomas Pouncy"
+  p.email          = "thomas.pouncy@gmail.com"
+  p.ignore_pattern = ["tmp/*", "script/*"]
+  p.development_dependencies = []
+end
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/app/controllers/funky_tabs/update_controller.rb

@@ -0,0 +1,14 @@
+class FunkyTabs::UpdateController < ApplicationController
+  layout false
+
+  def funky_tab_action
+    tab,tab_action,tab_action_id = FunkyTabs.tab_and_tab_action_from_location_hash(params[:location_hash])
+    action_to_call = FunkyTabs.content_path_for_tab_and_tab_action(tab,tab_action,tab_action_id)
+    redirect_to action_to_call+"?funky_tabs=true&location_hash=#{params[:location_hash]}" and return unless action_to_call.include?("?")
+    redirect_to action_to_call+"&funky_tabs=true&location_hash=#{params[:location_hash]}" and return
+  end
+
+  def missing_funky_tab
+    render FunkyTabs.missing_tab_action_path,:layout=>false and return
+  end
+end

data/app/views/funky_tabs/update/_ajax.js.erb

@@ -0,0 +1 @@
+funkyTabsAjaxCall('<%= @location_hash_for_ajax %>');

data/app/views/funky_tabs/update/_render_funky_tabs.html.erb

@@ -0,0 +1,68 @@
+<!-- BEGIN Funky Tabs -->
+<div id="funky_tabs">
+        <ul class="css-tabs">
+                <% FunkyTabs.tabs.each_index do |tab_index| %>
+                        <li id="funky_tabs_list-<%= tab_index %>" class="funky_tabs_list"><a href="#funky_tab-<%= tab_index %>"><%= FunkyTabs.tabs[tab_index].title %></a></li>
+                <% end %>
+        </ul>
+        <% FunkyTabs.tabs.each_index do |tab_index| %>
+                <div id="funky_tab-<%= tab_index %>" class="funky_tab"></div>
+        <% end %>
+</div>
+<div style="clear:both;"></div>
+<script type="text/javascript">
+function selectFunkyTab(tab_index){
+        jQuery('div#funky_tabs li.funky_tabs_list').removeClass('selected_tab');
+        jQuery('ul.css-tabs li#funky_tabs_list-'+tab_index).addClass('selected_tab');
+        jQuery('div#funky_tabs div.funky_tab').removeClass('selected_tab_div');
+        jQuery('div#funky_tabs div#funky_tab-'+tab_index).addClass('selected_tab_div');
+        if(load_on_select){
+                funkyTabsAjaxCall(tab_index);
+        } else  {
+                load_on_select = true;
+        }
+        <%= FunkyTabs.tab_select_callback.gsub(/:tab_number/,'tab_index') unless FunkyTabs.tab_select_callback.nil? %>
+}
+function funkyTabsAjaxCall(location_hash){
+        call_hash_change = false;
+        jQuery('div#funky_tabs div.funky_tab').html("<%= raw(FunkyTabs.loading_html) %>");
+        window.location.hash = location_hash;
+        jQuery("div#funky_tabs div.selected_tab_div").load("/funky_tabs/update/funky_tab_action?location_hash="+location_hash);
+}
+function hashChangeEvent(){
+        if(call_hash_change){
+                funkyTabsAjaxCall(location.hash.replace("#",""));
+        } else {
+                call_hash_change = true;
+        }
+}
+if(typeof(jQuery(window).hashchange) == "undefined"){
+        // dont have special plugin, so use onhashchange event. NOTE: this will not work in ie 6 or 7
+        window.onhashchange = hashChangeEvent;
+} else {
+        // if we can find the hashchange jquery plugin (http://benalman.com/projects/jquery-hashchange-plugin/), then use it
+        jQuery(window).hashchange(hashChangeEvent);
+}
+var load_on_select = true;
+var call_hash_change = true;
+jQuery(function() {
+        var initial_tab = <%= FunkyTabs.default_tab_index %>;
+        if(window.location.hash != ""){
+                initial_tab = parseInt(window.location.hash.replace("#","").split("-")[0]);
+        }
+        var tab = jQuery("#funky_tabs").tabs({
+                show: function(event,ui){
+                },
+                select: function(event,ui){
+                        selectFunkyTab(ui.index);
+                },
+                effect: 'ajax'
+        });
+        if(initial_tab == <%= FunkyTabs.default_tab_index %>){
+                selectFunkyTab(initial_tab);
+        } else {
+                jQuery("div#funky_tabs").tabs("select",initial_tab);
+        }
+});
+</script>
+<!-- END Funky Tabs -->

data/app/views/funky_tabs/update/missing_tab.html.erb

@@ -0,0 +1 @@
+That tab action appears to be missing. We apologize for the inconvenience.

data/app/views/funky_tabs/update/update_tab.html.erb

@@ -0,0 +1,10 @@
+<script type="text/javascript">
+window.location.hash = '<%= @location_hash %>';
+jQuery("div#funky_tabs div#funky_tab-<%= @tab_index %>").html("<%= escape_javascript(@render_content) %>");
+if(!jQuery("div#funky_tabs div#funky_tab-<%= @tab_index %>").hasClass('selected_tab_div')){
+        load_on_select = false;
+        jQuery("#funky_tabs").tabs("select", <%= @tab_index %>);
+}
+<%= FunkyTabs.tab_load_callback.gsub(/:tab_number/,@tab_index) unless FunkyTabs.tab_load_callback.nil? %>
+</script>
+

data/config/routes.rb

@@ -0,0 +1,5 @@
+Rails.application.routes.draw do
+  scope "funky_tabs", :module=>:funky_tabs, :as => 'funky_tabs' do
+    match "update(/:action(/:id(/:format)))", :controller=>:update
+  end
+end

data/funky_tabs.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{funky_tabs}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Thomas Pouncy"]
+  s.date = %q{2011-05-20}
+  s.description = %q{Create Ajaxified tabs with simple history through window location hashes for Rails.}
+  s.email = %q{thomas.pouncy@gmail.com}
+  s.extra_rdoc_files = ["CHANGELOG", "README.rdoc", "lib/funky_tabs.rb", "lib/funky_tabs/helpers.rb", "lib/funky_tabs/rails.rb", "lib/funky_tabs/renderers.rb", "lib/funky_tabs/tab.rb", "lib/funky_tabs/tab_action.rb"]
+  s.files = ["CHANGELOG", "Manifest", "README.rdoc", "Rakefile", "app/controllers/funky_tabs/update_controller.rb", "app/views/funky_tabs/update/_ajax.js.erb", "app/views/funky_tabs/update/_render_funky_tabs.html.erb", "app/views/funky_tabs/update/missing_tab.html.erb", "app/views/funky_tabs/update/update_tab.html.erb", "config/routes.rb", "funky_tabs.gemspec", "init.rb", "lib/funky_tabs.rb", "lib/funky_tabs/helpers.rb", "lib/funky_tabs/rails.rb", "lib/funky_tabs/renderers.rb", "lib/funky_tabs/tab.rb", "lib/funky_tabs/tab_action.rb", "test/funky_tabs_test.rb"]
+  s.homepage = %q{http://github.com/thomaspouncy/funky_tabs}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Funky_tabs", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{funky_tabs}
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Create Ajaxified tabs with simple history through window location hashes for Rails.}
+  s.test_files = ["test/funky_tabs_test.rb"]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'funky_tabs'

data/lib/funky_tabs/helpers.rb

@@ -0,0 +1,32 @@
+require 'funky_tabs'
+require 'rails'
+
+module FunkyTabs
+  module Helpers
+    def self.included(base)
+      base.class_eval do
+        def render_funky_tabs
+          #@tab_data = FunkyTabs
+          return render_to_string :partial=>"funky_tabs/update/render_funky_tabs"
+        end
+
+        def location_hash_for_funky_tab(tab,tab_action=nil,tab_action_id=nil)
+          return FunkyTabs.location_hash_for_tab_action(tab,tab_action,tab_action_id)
+        end
+
+        def redirect_to_funky_tab(tab,tab_action=nil,tab_action_id=nil)
+          params[:location_hash] = FunkyTabs.location_hash_for_tab_action(tab,tab_action,tab_action_id)
+          action_to_call = FunkyTabs.content_path_for_tab_and_tab_action(tab,tab_action)
+          redirect_to action_to_call+"?funky_tabs=true&location_hash=#{params[:location_hash]}" and return unless action_to_call.include?("?")
+          redirect_to action_to_call+"&funky_tabs=true&location_hash=#{params[:location_hash]}" and return
+        end
+
+        def js_to_funky_tab(tab,tab_action=nil,tab_action_id=nil)
+          @location_hash_for_ajax = FunkyTabs.location_hash_for_tab_action(tab,tab_action,tab_action_id)
+          return render_to_string :partial=>"funky_tabs/update/ajax.js"
+        end
+        helper_method :render_funky_tabs, :redirect_to_funky_tab, :js_to_funky_tab
+      end
+    end
+  end
+end

data/lib/funky_tabs/rails.rb

@@ -0,0 +1,7 @@
+require 'funky_tabs'
+require 'rails'
+
+module FunkyTabs
+  class Engine < Rails::Engine
+  end
+end

data/lib/funky_tabs/renderers.rb

@@ -0,0 +1,19 @@
+require 'funky_tabs'
+require 'rails'
+
+module FunkyTabs
+  module Renderers
+    extend ActiveSupport::Concern
+
+    module InstanceMethods
+      def render(*args, &block)
+        super(*args, &block) and return if params[:funky_tabs].nil?
+        @tab_index = FunkyTabs.tab_index_from_location_hash(params[:location_hash])
+        super(*args, &block) and return if @tab_index.nil?
+        @location_hash = params[:location_hash]
+        @render_content = render_to_string(*args, &block)
+        super(:template=>"funky_tabs/update/update_tab",:layout=>false)
+      end
+    end
+  end
+end

data/lib/funky_tabs/tab.rb

@@ -0,0 +1,80 @@
+require 'funky_tabs'
+require 'rails'
+
+module FunkyTabs
+  class Tab
+    attr_accessor :name
+    attr_accessor :title
+    attr_accessor :default_tab_action
+    attr_accessor :tab_actions
+
+    #default values for attrs
+    def title
+      @title ||= name
+    end
+    def tab_actions
+      @tab_actions ||= []
+    end
+    def default_tab_action
+      @default_tab_action ||= add_tab_action("index")
+    end
+
+    #tab methods
+    def initialize(hash_or_string)
+      # initialize default tab action unless the user has provided one of their own
+      default_tab_action unless hash_or_string.is_a?(Hash) && hash_or_string.has_key?(:default_tab_action)
+
+      return set_attrs({:name=>hash_or_string}) if hash_or_string.is_a?(String)
+      return set_attrs(hash_or_string) if hash_or_string.is_a?(Hash)
+      raise FunkyTabsException.new("invalid tab parameters #{hash_or_string.inspect}")
+    end
+
+    def set_attrs(attrs_hash)
+      raise FunkyTabsException.new("invalid tab attrs format #{attrs_hash.inspect}") unless attrs_hash.is_a?(Hash)
+      # in order to make sure that default action gets called after actions have been instantiated, sort hash keys
+      attrs_hash.keys.sort.each do |key|
+        self.send("#{key.to_s}=",attrs_hash[key])
+      end
+      return self
+    end
+
+    # when setting a default action, create and link to action if doesnt exist
+    def default_tab_action=(sym_or_string)
+      @default_tab_action = add_tab_action(sym_or_string)
+    end
+
+    # Right now this method just appends actions, it doesn't delete them.
+    def tab_actions=(array_or_string_or_hash)
+      return add_tab_action(array_or_string_or_hash) if array_or_string_or_hash.is_a?(String)||array_or_string_or_hash.is_a?(Hash)
+      return add_tab_actions(array_or_string_or_hash) if array_or_string_or_hash.is_a?(Array)
+      raise FunkyTabsException.new("invalid actions format #{array_or_string_or_hash.inspect}")
+    end
+
+    def find_tab_action(tab_action_or_string_or_hash)
+      return nil if tab_action_or_string_or_hash.nil? || tab_actions.blank?
+      tab_action_or_string_or_hash = tab_action_or_string_or_hash.to_s if tab_action_or_string_or_hash.is_a?(Symbol)
+      return tab_actions.index {|action| action.name.downcase == tab_action_or_string_or_hash.downcase} if tab_action_or_string_or_hash.is_a?(String)
+      return tab_actions.index {|action| action.name == tab_action_or_string_or_hash[:name] } if tab_action_or_string_or_hash.is_a?(Hash)
+      return tab_actions.index(tab_action_or_string_or_hash) if tab_action_or_string_or_hash.is_a?(FunkyTabs::TabAction)
+      raise FunkyTabsException.new("Dont know how to find an action with #{tab_action_or_string_or_hash.inspect}")
+    end
+
+    def add_tab_action(string_or_hash)
+      tab_action_index = find_tab_action(string_or_hash)
+      if tab_action_index.nil?
+        new_tab_action = FunkyTabs::TabAction.new(string_or_hash)
+        tab_actions << new_tab_action
+        return new_tab_action
+      else
+        return tab_actions[tab_action_index]
+      end
+    end
+
+    def add_tab_actions(array_of_properties)
+      array_of_properties.each do |action_properties|
+        add_tab_action(action_properties)
+      end
+      return tab_actions
+    end
+  end
+end

data/lib/funky_tabs/tab_action.rb

@@ -0,0 +1,23 @@
+require 'funky_tabs'
+require 'rails'
+
+module FunkyTabs
+  class TabAction
+    attr_accessor :name
+    attr_accessor :content_path
+
+    def initialize(hash_or_string)
+      return set_attrs({:name=>hash_or_string}) if hash_or_string.is_a?(String)
+      return set_attrs(hash_or_string) if hash_or_string.is_a?(Hash)
+      raise FunkyTabsException.new("invalid action parameters #{hash_or_string.inspect}")
+    end
+
+    def set_attrs(attrs_hash)
+      raise FunkyTabsException.new("invalid action attrs format #{attrs_hash.inspect}") unless attrs_hash.is_a?(Hash)
+      attrs_hash.each do |key,val|
+        self.send("#{key}=",val)
+      end
+      return self
+    end
+  end
+end

data/lib/funky_tabs.rb

@@ -0,0 +1,159 @@
+require 'funky_tabs'
+require 'rails'
+require 'action_controller'
+
+module FunkyTabs
+  require 'funky_tabs/helpers'
+  require 'funky_tabs/renderers'
+  require 'funky_tabs/rails'
+  require 'funky_tabs/tab'
+  require 'funky_tabs/tab_action'
+
+  class FunkyTabsException < Exception
+  end
+
+  ActionController::Base.send :include, FunkyTabs::Helpers
+  ActionController::Base.send :include, FunkyTabs::Renderers
+
+  mattr_accessor :tabs
+  def self.tabs
+    @@tabs ||= []
+  end
+
+  # make sure to include / at end of tab controller
+  mattr_accessor :default_tab_index
+  def self.default_tab_index
+    @@default_tab_index ||= 0
+  end
+  mattr_accessor :default_tabs_controller
+  def self.default_tabs_controller
+    @@default_tabs_controller ||= "funky_tabs/update"
+  end
+  mattr_accessor :missing_tab_action_path
+  def self.missing_tab_action_path
+    @@missing_tab_action_path ||= "/funky_tabs/update/missing_tab"
+  end
+  mattr_accessor :tab_load_callback
+  mattr_accessor :tab_select_callback
+  mattr_accessor :loading_html
+  def self.loading_html
+    @@loading_html ||= "Loading..."
+  end
+
+  def self.setup
+    yield self
+  end
+
+  def self.add_tab(string_or_hash)
+    tab_index = find_tab(string_or_hash)
+    if tab_index.nil?
+      # if the tab doesnt exist, create it
+      new_tab = FunkyTabs::Tab.new(string_or_hash)
+      tabs << new_tab
+      return new_tab
+    else
+      # if the tab exists, return it
+      return tabs[tab_index]
+    end
+    raise FunkyTabsException.new("Dont know how to add this tab with #{string_or_hash.inspect}")
+  end
+
+  def self.add_tabs(array_of_properties)
+    raise FunkyTabsException.new("dont know how to create tabs from #{array_of_properties.inspect}") unless array_of_properties.is_a?(Array)
+    array_of_properties.each do |tab_properties|
+      add_tab(tab_properties)
+    end
+    return tabs
+  end
+
+  def self.tab(sym_or_string)
+    tab_index = find_tab(sym_or_string.to_s)
+    return tabs[tab_index] unless tab_index.nil?
+    return nil
+  end
+
+  def self.find_tab(tab_or_string_or_hash)
+    return nil if tab_or_string_or_hash.blank? || tabs.blank?
+    tab_or_string_or_hash = tab_or_string_or_hash.to_s if tab_or_string_or_hash.is_a?(Symbol)
+    return tabs.index {|tab| tab.name.downcase == tab_or_string_or_hash.downcase} if tab_or_string_or_hash.is_a?(String)
+    return tabs.index {|action| action.name == tab_or_string_or_hash[:name] } if tab_or_string_or_hash.is_a?(Hash)
+    return tabs.index(tab_or_string_or_hash) if tab_or_string_or_hash.is_a?(FunkyTabs::Tab)
+    raise FunkyTabsException.new("dont know how to find tab with #{tab_or_string_or_hash.inspect}")
+  end
+
+  def self.location_hash_for_tab_action(tab,tab_action=nil,tab_action_id=nil)
+    return nil if tab.nil?
+
+    tab_index = find_tab(tab)
+    return nil if tab_index.nil?
+
+    tab_action_index = tabs[tab_index].find_tab_action(tab_action)
+
+    return tab_index.to_s if tab_action_index.nil?
+    return "#{tab_index}-#{tab_action_index}" if tab_action_id.nil?
+    return "#{tab_index}-#{tab_action_index}-#{tab_action_id}"
+  end
+
+  def self.location_hash_for_indices(tab_index,tab_action_index=nil)
+    tab_index = tab_index.to_i
+    tab_action_index = tab_action_index.to_i unless tab_action_index.nil?
+    tab = tab_index.nil? ? nil : tabs[tab_index]
+    tab_action = nil
+    tab_action = tab.tab_actions[tab_action_index] unless tab.nil? || tab_action_index.nil?
+    return location_hash_for_tab_action(tab,tab_action)
+  end
+
+  def self.content_path_for_tab_and_tab_action(tab,tab_action=nil,tab_action_id=nil)
+    tab_index = find_tab(tab)
+    return missing_tab_action_path if tab_index.nil?
+    tab = tabs[tab_index]
+    tab_action_index = tab.find_tab_action(tab_action||tab.default_tab_action)
+    return missing_tab_action_path if tab_action_index.nil?
+    tab_action = tab.tab_actions[tab_action_index]
+    unless tab_action.content_path.blank?
+      return tab_action.content_path if tab_action_id.nil?
+      return tab_action.content_path+"&id=#{tab_action_id}" if tab_action.content_path.include?("?")
+      return tab_action.content_path+"?id=#{tab_action_id}"
+    end
+    if tab_action.name.downcase == "index"
+      content_path = "/#{default_tabs_controller}/#{tab.name.gsub(/\s/,"_").downcase}_index"
+    else
+      content_path = "/#{default_tabs_controller}/#{tab_action.name.gsub(/\s/,"_").downcase}_#{tab.name.gsub(/\s/,"_").downcase}"
+    end
+    return content_path if tab_action_id.nil?
+    return "#{content_path}/#{tab_action_id}"
+  end
+
+  def self.tab_and_tab_action_from_location_hash(location_hash)
+    return nil,nil,nil if tabs.blank?
+    return tabs[default_tab_index],nil,nil if location_hash.blank?
+
+    indices = location_hash.to_s.split("-")
+    return nil,nil,nil if indices.first.nil?
+    tab_index = indices.first.to_i
+    tab = tabs[tab_index]
+    return nil,nil,nil if tab.nil?
+    tab_action_index = indices[1].to_i
+    return tab,nil,nil if tab_action_index.nil?
+    return tab,nil,nil if tab_action_index.to_i >= tab.tab_actions.length
+    tab_action = tab.tab_actions[tab_action_index]
+
+    tab_action_id = indices[2]
+    return tab,tab_action,tab_action_id
+  end
+
+  def self.tab_index_from_location_hash(location_hash)
+    return default_tab_index if tabs.blank? || location_hash.blank?
+    indices = location_hash.to_s.split("-");
+    return default_tab_index if indices.first.nil?
+    tab = tabs[indices.first.to_i]
+    return default_tab_index if tab.nil?
+    return indices.first
+  end
+
+  # TODO: Figure out way to reset all mattr_accessors
+  def self.reset
+    tabs.clear
+    tab_root = ""
+  end
+end

data/test/funky_tabs_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class FunkyTabsTest < ActiveSupport::TestCase
+  def setup
+    FunkyTabs.reset
+    FunkyTabs.add_tab("first tab")
+    FunkyTabs.add_tab(:name=>"second tab",:default_tab_action=>"edit")
+    FunkyTabs.add_tab(:name=>"third tab",:tab_actions=>"edit")
+    FunkyTabs.add_tab(:name=>"fourth tab",:tab_actions=>["edit",{:name=>"update",:content_path=>"test_path",:use_regular_content_paths=>false}])
+  end
+
+  test "content_path_for_location_hash returns default action path given no action" do
+    assert_equal "funky_tabs/first_tab/index",FunkyTabs.content_path_for_location_hash("0")
+  end
+
+  test "content_path_for_location_hash returns action path given action" do
+    assert_equal "funky_tabs/third_tab/edit",FunkyTabs.content_path_for_location_hash("2-1")
+  end
+
+  test "content_path_for_location_hash returns nil given invalid object" do
+    assert_nil FunkyTabs.content_path_for_location_hash("bogus hash")
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: funky_tabs
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Thomas Pouncy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-20 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Create Ajaxified tabs with simple history through window location hashes for Rails.
+email: thomas.pouncy@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+- README.rdoc
+- lib/funky_tabs.rb
+- lib/funky_tabs/helpers.rb
+- lib/funky_tabs/rails.rb
+- lib/funky_tabs/renderers.rb
+- lib/funky_tabs/tab.rb
+- lib/funky_tabs/tab_action.rb
+files: 
+- CHANGELOG
+- Manifest
+- README.rdoc
+- Rakefile
+- app/controllers/funky_tabs/update_controller.rb
+- app/views/funky_tabs/update/_ajax.js.erb
+- app/views/funky_tabs/update/_render_funky_tabs.html.erb
+- app/views/funky_tabs/update/missing_tab.html.erb
+- app/views/funky_tabs/update/update_tab.html.erb
+- config/routes.rb
+- funky_tabs.gemspec
+- init.rb
+- lib/funky_tabs.rb
+- lib/funky_tabs/helpers.rb
+- lib/funky_tabs/rails.rb
+- lib/funky_tabs/renderers.rb
+- lib/funky_tabs/tab.rb
+- lib/funky_tabs/tab_action.rb
+- test/funky_tabs_test.rb
+has_rdoc: true
+homepage: http://github.com/thomaspouncy/funky_tabs
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Funky_tabs
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+requirements: []
+
+rubyforge_project: funky_tabs
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Create Ajaxified tabs with simple history through window location hashes for Rails.
+test_files: 
+- test/funky_tabs_test.rb