tabulous 1.3.2 → 2.0.0

data/CHANGELOG.rdoc

@@ -1,40 +0,0 @@
-== 1.3.2 (April 12, 2013)
-* Fixed a bug where the gem's gemspec did not include all of the files.
-
-== 1.3.1 (April 6, 2013)
-* Ensured compatibility with Rails 4.0.0.beta1 and Ruby 2.0.
-* Maintained compatibility with Rails 3.0, 3.1 and 3.2 and Ruby 1.8 and 1.9.
-* Complete overhaul of the test applications to make them easier to test across multiple versions of
-  Rails and Ruby.
-
-== 1.3.0 (March 20, 2012)
-* Added config.subtabs_ul_class.
-* Verified that tabulous works with Ruby 1.9.3.
-
-== 1.2.0 (February 8, 2012)
-* Added support for Twitter Bootstrap (version 2).
-* Noted in the documentation that tabulous works with Rails 3.2.
-
-== 1.1.0 (January 10, 2012)
-* Deprecated the raise_error_if_no_tab_found configuration setting.  Replaced it with
-  config.when_action_has_no_tab.
-* Changed some gem versions in the development dependencies.
-
-== 1.0.3 (November 6, 2011)
-* Added support for Rails 3.1 (finally!).
-
-== 1.0.2 (April 19, 2011)
-* Fixed bug where the tabs generator would crash if there were index routes that were not named.
-
-== 1.0.1 (March 9, 2011)
-* No longer requires Rubygems version > 1.4.0; requires > 1.3.7 instead.
-
-== 1.0.0 (March 4, 2011)
-* Moved tab file from config/initializers/tabulous.rb to app/tabs/tabulous.rb.
-* Changed syntax so that config.tabs and config.actions accepts a block.
-
-== 0.0.2 (March 2, 2011)
-* Changed homepage in gemspec.
-
-== 0.0.1 (March 2, 2011)
-* Initial release.

data/README.rdoc

@@ -1,81 +0,0 @@
-= Tabulous
-
-== Description
-
-Tabulous provides an easy way to add tabs to your Rails application.
-
-== Requirements
-
-Tabulous works with Rails 3.0, 3.1, 3.2 and 4.0.  It has been tested on Ruby 1.8.7, 1.9.3 and 2.0.0.
-
-== Usage
-
-Traditionally, implementing tabs in Rails involves adding logic to your views and sprinkling
-tab-related code all over your controllers.  Tabulous takes a different approach and
-consolidates all of the tab-related code into one configuration file.  Apart from this
-configuration file, you just have to call <%= tabs %> and <%= subtabs %> in your view layout(s)
-and then create your own CSS styles for the tabs.
-
-To get started, add the gem to your Rails application's Gemfile and install it using:
-
-  bundle install
-
-Then generate the tab file:
-
-  rails generate tabs
-
-This will generate app/tabs/tabulous.rb.  Open the file and configure it to your liking.
-You'll notice the code is formatted into a grid.  After you edit the file, run the following rake
-task to prettify the code back into a nice grid:
-
-  rake tabs:format
-
-Make sure you call the following view helpers in your layout(s):
-
-  <%= tabs %>
-  <%= subtabs %>
-
-The tabs helper will generate markup that looks like this:
-
-  <div id="tabs">
-    <ul>
-      <li class="active enabled"><span class="tab">Explanation</span></li>
-      <li class="inactive enabled"><a href="/galaxies/elliptical_galaxies" class="tab">Galaxies</a></li>
-      <li class="inactive enabled"><a href="/exoplanets" class="tab">Planets</a></li>
-      <li class="inactive enabled"><a href="/stars" class="tab">Stars</a></li>
-      <li class="inactive disabled"><span class="tab">Asteroids</span></li>
-    </ul>
-  </div>
-
-And the subtabs helper will generate markup that looks like this:
-
-  <div id="subtabs">
-    <ul>
-      <li class="active enabled"><span class="tab">Exoplanets</span></li>
-      <li class="inactive enabled"><a href="/rogue_planets" class="tab">Rogue Planets</a></li>
-    </ul>
-  </div>
-
-Tabulous will start you off with some CSS scaffolding but you'll eventually want to create your own
-CSS.
-
-== Examples
-
-There is a tutorial at http://techiferous.com/2011/03/tutorial-for-adding-tabs-to-rails-using-tabulous/
-
-== Twitter Bootstrap
-
-To get tabulous to work with Twitter Bootstrap version 2, make sure the
-following values are set in app/tabs/tabulous.rb:
-
-* config.css.scaffolding = false
-* config.tabs_ul_class = "nav nav-pills" # or whatever Bootstrap class you want
-* config.bootstrap_style_subtabs = true
-* config.active_tab_clickable = true
-
-When config.bootstrap_style_subtabs is set to true, the subtabs are rendered
-inside the tab markup, so you only need to call the tabs helper in your
-layout, not the subtabs helper.
-
-Also note that if you use Twitter Bootstrap, you lose the ability to disable
-individual subtabs.

data/lib/tabulous/formatter.rb

@@ -1,276 +0,0 @@
-require 'active_support/core_ext/string'
-
-module Tabulous
-
-
-
-  class Formatter
-    def self.format(lines)
-      Parser.new(lines).go
-    end
-  end
-
-
-
-  class Parser
-
-    def initialize(lines)
-      @input_lines = lines
-    end
-
-    def go
-      output_lines = []
-      @current_table = nil
-      @input_lines.each do |input_line|
-        line = Line.new(input_line)
-        if @current_table && line.end_of_table?
-          output_lines += Prettifier.new(@current_table).prettify
-          @current_table = nil
-        end
-        if @current_table
-          at_start_of_header = (@current_table.indentation.nil? && line.horizontal_rule?)
-          at_top_header_row = @current_table.header_row.empty? && line.header_row?
-          at_bottom_header_row = !@current_table.header_row.empty? && line.header_row?
-          if at_start_of_header
-            @current_table.indentation = line.indentation
-          elsif at_top_header_row
-            @current_table.header_row = line.header_row
-          elsif line.table_row?
-            @current_table.add_row(*line.table_row)
-          elsif line.blank?
-            # blank lines go away
-          elsif line.horizontal_rule?
-            # we can also safely ignore header lines as they will be regenerated
-          elsif at_bottom_header_row
-            # we can also safely ignore this as it will be regenerated
-          else
-            raise FormattingError,
-                  "Only properly formatted table rows expected. " +
-                  "For example, comments can only appear at the end of table rows, not " +
-                  "between them.  Aborting."
-          end
-        else
-          output_lines << line.text
-        end
-        if !@current_table && line.beginning_of_table?
-          @current_table = Table.new
-        end
-      end
-      return output_lines
-    end
-
-  end
-
-
-
-  class Table
-
-    attr_reader :header_row, :end_of_row_comments, :rows
-    attr_accessor :indentation
-
-    def initialize
-      @rows = []
-      @header_row = []
-      @end_of_row_comments = []
-      @indentation = nil
-    end
-
-    def header_row=(val)
-      @header_row = val
-      calculate_column_widths
-    end
-
-    def add_row(cells, end_of_row_comment)
-      @rows << cells
-      @end_of_row_comments << end_of_row_comment
-      calculate_column_widths
-    end
-
-    def column_width(column_number)
-      @column_widths[column_number]
-    end
-
-    def number_of_columns
-      @header_row.size
-    end
-
-    private
-
-    def calculate_column_widths
-      @column_widths = {}
-      for column in (0..number_of_columns-1)
-        column_cells = [@header_row[column]]
-        row_number = 0
-        column_cells += @rows.map do |row|
-          row_number += 1
-          if row[column].nil?
-            raise FormattingError,
-                  "There appears to be at least one missing table cell, probably " +
-                  "in row ##{row_number}, column ##{column+1}.  Remember that commas " +
-                  "that separate table cells must be surrounded by spaces or " +
-                  "the formatter gets confused."
-          else
-            row[column]
-          end
-        end
-        @column_widths[column] = column_cells.map(&:length).max
-      end
-    end
-
-  end
-
-
-
-  class Line
-
-    def initialize(line)
-      @line = line
-    end
-
-    def text
-      @line
-    end
-
-    def beginning_of_table?
-      line = @line.split('#').first # naively strip out comments
-      return false if line.nil?
-      line.strip == '['
-    end
-  
-    def end_of_table?
-      line = @line.split('#').first # naively strip out comments
-      return false if line.nil?
-      line.strip == ']'
-    end
-
-    def horizontal_rule?
-      @line =~ /^(\s*)#--/
-    end
-
-    def header_row?
-      stripped_line = @line.strip
-      stripped_line.starts_with?('# ') && stripped_line.slice('|')
-    end
-
-    def table_row?
-      stripped_line = @line.strip
-      stripped_line.starts_with?('[')
-    end
-
-    def blank?
-      @line.strip.blank?
-    end
-
-    def indentation
-      @line =~ /^(\s*)\S+/
-      $1.size
-    end
-
-    def header_row
-      return nil unless header_row?
-      cells = @line.strip.split('|')
-      first_cell = cells.shift
-      first_cell = first_cell.split('#').last.strip
-      last_cell = cells.pop
-      if last_cell =~ /#\s*\S+/
-        raise FormattingError,
-              "No extra text is allowed on the table header lines.  " + 
-              "Text was detected to the right of the table headers; aborting. "
-      end
-      last_cell = last_cell.split('#').first.strip
-      [first_cell] + cells.map(&:strip) + [last_cell]
-    end
-
-    def table_row
-      if @line.strip =~ /^\[(.+)\],(\s*|\s*#.*)$/
-        cells = $1
-        end_of_row_comment = $2
-        cells = cells.split(' , ').map(&:strip)
-        [cells, end_of_row_comment]
-      else
-        raise FormattingError,
-              "Only properly formatted table rows expected. " +
-              "For example, comments can only appear at the end of table rows, not " +
-              "between them.  Aborting."
-      end
-    end
-
-  end
-
-
-
-  class Prettifier
-
-    def initialize(table)
-      @table = table
-    end
-
-    def prettify
-      output_lines = []
-      output_lines += build_header_row
-      @table.rows.each_with_index do |cells, index|
-        if cells.size != @table.number_of_columns
-          if cells.size > 0
-            raise FormattingError,
-                  "Wrong number of table cells in row #{cells.first}.  " +
-                  "Expected #{@table.number_of_columns} cells, got #{cells.size}.  " +
-                  "Remember that if you put Ruby expressions inside of table cells, the " +
-                  "expressions should not have commas surrounded by spaces or the " +
-                  "formatter gets confused."
-          else
-            raise FormattingError,
-                  "One of the tables has the wrong number of cells."
-          end
-        end
-        if cells.map(&:strip).any?(&:blank?)
-            raise FormattingError,
-                  "You have at least one empty cell in row ##{index+1}."
-        end
-        for column in (0..@table.number_of_columns-1)
-          cells[column] = build_cell(cells[column], @table.column_width(column))
-        end
-        line = cells.join(',')
-        line = indent('[' + line + '],')
-        end_of_row_comment = @table.end_of_row_comments[index]
-        unless end_of_row_comment.blank?
-          line += '  ' + end_of_row_comment.strip
-        end
-        output_lines << line
-      end
-      output_lines += build_header_row
-      output_lines
-    end
-
-    private
-
-    def build_cell(text, width)
-      padding = ' ' * 4
-      padding + text.ljust(width) + padding
-    end
-
-    def indent(s)
-      ' ' * @table.indentation + s
-    end
-
-    def build_header_row
-      output_lines = []
-      column = 0
-      headings = @table.header_row.map do |heading|
-        result = build_cell(heading, @table.column_width(column))
-        column += 1
-        result
-      end
-      header = headings.join('|')
-      header_divider = indent('#' + ('-' * header.size) + '#')
-      header = indent('#' + header + '#')
-      output_lines << header_divider
-      output_lines << header
-      output_lines << header_divider
-      output_lines
-    end
-
-  end
-
-
-
-end

data/lib/tabulous/helpers.rb

@@ -1,13 +0,0 @@
-module Tabulous
-  module Helpers
-    
-    def tabs
-      Tabulous.render_tabs(self)
-    end
-
-    def subtabs
-      Tabulous.render_subtabs(self)
-    end
-
-  end
-end

data/lib/tabulous/options.rb

@@ -1,58 +0,0 @@
-module Tabulous
-
-  class Css
-    attr_accessor :scaffolding
-    attr_accessor :background_color
-    attr_accessor :text_color
-    attr_accessor :active_tab_color
-    attr_accessor :hover_tab_color
-    attr_accessor :inactive_tab_color
-    attr_accessor :inactive_text_color
-    def initialize
-      @scaffolding = false
-      @background_color = '#ccc'
-      @text_color = '#444'
-      @active_tab_color = 'white'
-      @hover_tab_color = '#ddd'
-      @inactive_tab_color = '#aaa'
-      @inactive_text_color = '#888'
-    end
-  end
-  
-  mattr_accessor :always_render_subtabs
-  @@always_render_subtabs = false
-
-  mattr_accessor :active_tab_clickable
-  @@active_tab_clickable = false
-
-  mattr_accessor :when_action_has_no_tab
-  @@when_action_has_no_tab = :raise_error
-
-  mattr_accessor :css
-  @@css = Css.new
-
-  mattr_accessor :html5
-  @@html5 = false
-
-  mattr_accessor :tabs_ul_class
-  @@tabs_ul_class = nil
-
-  mattr_accessor :subtabs_ul_class
-  @@subtabs_ul_class = nil
-
-  mattr_accessor :bootstrap_style_subtabs
-  @@bootstrap_style_subtabs = false
-
-  def self.raise_error_if_no_tab_found=(value)
-    msg = "DEPRECATION WARNING: Tabulous's config.raise_error_if_no_tab_found "
-    msg << "has been replaced by config.when_action_has_no_tab. "
-    msg << "Acceptable values are :raise_error, :do_not_render, or :render."
-    Rails.logger.warn msg
-    if value
-      self.when_action_has_no_tab = :raise_error
-    else
-      self.when_action_has_no_tab = :do_not_render
-    end
-  end
-
-end

data/lib/tasks/tabulous.rake

@@ -1,11 +0,0 @@
-namespace :tabs do
-  desc "Prettify app/tabs/tabulous.rb"
-  task :format do
-    require File.expand_path('../tabulous/formatter', File.dirname(__FILE__))
-    filename = File.join(Rails.root.to_s, 'app', 'tabs', 'tabulous.rb')
-    reformatted = Tabulous::Formatter.format(IO.readlines(filename))
-    File.open(filename, 'w') do |f|
-      f.puts reformatted
-    end
-  end
-end

data/spec/applications/README

@@ -1,109 +0,0 @@
-# Test Applications
-
-
-
-## What's the point?
-
-Since the behavior of tabulous affects the application as a whole, to really
-test it well we need to use integration tests.
-
-We also need to have several different test applications in order to test
-various configurations, such as using it with Twitter Bootstrap, using it with
-or without subtabs, etc.
-
-And finally, we care that tabulous works well in multiple versions of Rails.
-
-So if we had four test applications and were testing against three versions of
-Rails, all of a sudden we've got twelve different applications and their
-accompanying tests to manage.  Ouch!
-
-So the whole point of this setup is to take away the pain of testing multiple
-test applications against multiple versions of Rails.
-
-
-
-## Okay, so how does this work?
-
-We use Rails application templates to generate our test apps.  This means that
-we don't want to make changes to any Rails test app directly, because those
-changes will get lost when the app is re-generated.
-
-Each kind of test application lives under its own directory in spec/applications
-(e.g., spec/applications/main).
-
-The Rails application template lives in this directory and should be called
-application_template.rb.  This gives instructions for how to generate the test
-app.
-
-When we generate a new test application and specify a Rails version, the test
-application will end up in spec/applications/[app_name]/[rails-version].
-
-When the application in generated, it uses the gems described in
-spec/applications/universal_gemfile.rb.
-
-Any files and directories in spec/applications/universal will be copied over to
-the new Rails app.  This is where we would put any tests that we would want to
-run in every one of our test applications, for example.
-
-Any files and directories in spec/applications/[app_name]/shared will be copied
-over to the new Rails app.  This is where we would put all of the tests that we
-would want run for this kind of test app.
-
-
-
-## So how do we generate a test app?
-
-Let's say Rails 17.0.4 is released and we want to test the "main" test app
-against this.  Run this script:
-
-$ script/create_test_app main 17.0.4
-
-This will create a Rails app in spec/applications/main/rails_17-0-4.  When it is
-finished generating, we can go into the new Rails app's directory and run tests
-like so:
-
-$ bundle exec rake test
-$ bundle exec rake spec
-$ bundle exec rake
-
-
-
-## So how do we set up a new kind of test application?
-
-* Create a new directory under spec/applications.
-* Create a new application_template.rb file in this directory.  Follow the
-  pattern of the other test app's application templates.
-* Create a shared directory in this directory.  Any files put here will be
-  copied when we generate a new Rails app based on the application template.
-* Any specs or tests should live in this shared directory.
-* If we need to add any gems to the Rails app, modify
-  spec/applications/universal_gemfile.rb.
-
-
-
-## WTF?! Why isn't this working for me?
-
-Two things can be particularly problematic when testing multiple versions of
-Rails apps from within a gem:
-
-### Wrong Gemfile
-
-Bundler can get confused and accidentally use the tabulous gem's Gemfile
-instead of the Gemfile found in the test app.  So if you have gem version
-problems, consider this.  More info is here: http://spectator.in/2011/01/28/bundler-in-subshells/
-
-### Wrong Rails Executable
-
-When you have multiple versions of Rails installed, it can be very difficult
-to target the correct version of the rails executable to use.  Even if you
-use the rails _version.number_ trick, the wrong version of Rails may still
-be used.  This is because rails is a dependency in tabulous's Gemfile, and so
-even if you try to force the usage of a different rails executable, the version
-specified in the Gemfile may be winning.  This probably depends on what tools
-you are using to manage your gems and rubies (rvm, Bundler, rubygems-bundler,
-etc.).
-
-If you have this problem, one way to get the generation of a new test application
-to work is to create a fresh, new gemset and install just that version of
-Rails in it.  Then you can create a new test application targeted to that
-version of Rails.

data/spec/applications/main/rails_3-0-20/spec/features/actions_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-
-describe 'an action' do
-
-  include TabHelpers
-
-  before(:each) do
-    use_tab_file %Q{
-      Tabulous.setup do |config|
-
-        config.tabs do
-          [
-            #------------------------------------------------------------------------------------------------------#
-            #    TAB NAME         |    DISPLAY TEXT     |    PATH                |    VISIBLE?    |    ENABLED?    #
-            #------------------------------------------------------------------------------------------------------#
-            [    :home_tab        ,    'Explanation'    ,    "/"                 ,    true        ,    true        ],
-            [    :galaxies_tab    ,    'Galaxies'       ,    "/galaxies"         ,    true        ,    true        ],
-            [    :stars_tab       ,    'Stars'          ,    "/stars"            ,    true        ,    true        ],
-            [    :planets_tab     ,    'Planets'        ,    "/planets"          ,    true        ,    true        ],
-            [    :subtabs_tab     ,    'Subtabs'        ,    "/subtabs/one"      ,    true        ,    true        ],
-            [    :one_subtab      ,    'One'            ,    "/subtabs/one"      ,    true        ,    true        ],
-            [    :two_subtab      ,    'Two'            ,    "/subtabs/two"      ,    true        ,    true        ],
-            [    :three_subtab    ,    'Three'          ,    "/subtabs/three"    ,    true        ,    true        ],
-            #------------------------------------------------------------------------------------------------------#
-            #    TAB NAME         |    DISPLAY TEXT     |    PATH                |    VISIBLE?    |    ENABLED?    #
-            #------------------------------------------------------------------------------------------------------#
-          ]
-        end
-
-        config.actions do
-          [
-            #-------------------------------------------------------------#
-            #    CONTROLLER    |    ACTION          |    TAB              #
-            #-------------------------------------------------------------#
-            [    :home         ,    :index          ,    :home_tab        ],
-            [    :galaxies     ,    :all_actions    ,    :galaxies_tab    ],
-            [    :stars        ,    :all_actions    ,    :stars_tab       ],
-            [    :planets      ,    :all_actions    ,    :planets_tab     ],
-            [    :subtabs      ,    :one            ,    :one_subtab      ],
-            [    :subtabs      ,    :two            ,    :two_subtab      ],
-            [    :subtabs      ,    :three          ,    :three_subtab    ],
-            #-------------------------------------------------------------#
-            #    CONTROLLER    |    ACTION          |    TAB              #
-            #-------------------------------------------------------------#
-          ]
-        end
-
-        config.css.scaffolding = true
-
-      end
-    }
-    visit '/'
-  end
-
-  context 'specified explicitly' do
-    context 'when visiting that action' do
-      before(:each) { visit '/' }
-      it 'should render the view associated with that action' do
-        page.should have_content('This tests tabulous in all sorts of configurations.')
-      end
-      it 'should activate the tab associated with that action' do
-        active_tab.should == 'Explanation'
-      end
-    end
-  end
-
-  context 'specified using :all_actions' do
-    context 'when visiting index' do
-      before(:each) { click_link 'Galaxies' }
-      it 'should render the view associated with that action' do
-        page.should have_content('Listing galaxies')
-      end
-      it 'should activate the tab associated with that action' do
-        active_tab.should == 'Galaxies'
-      end
-    end
-
-    context 'when visiting new' do
-      before(:each) { click_link 'Galaxies'; click_link 'New Galaxy' }
-      it 'should render the view associated with that action' do
-        page.should have_content('New galaxy')
-      end
-      it 'should activate the tab associated with that action' do
-        active_tab.should == 'Galaxies'
-      end
-    end
-  end
-
-  context 'associated with a subtab' do
-    context 'specified explicitly' do
-      context 'when visiting that action' do
-        before(:each) { click_link 'Subtabs'; click_link 'Two' }
-        it 'should render the view associated with that action' do
-          page.should have_content('Subtab #2')
-        end
-        it 'should activate the tab and subtab associated with that action' do
-          active_tab.should == 'Subtabs'
-          active_subtab.should == 'Two'
-        end
-      end
-    end
-  end
-end