tabulous 0.0.1

data/lib/tabulous/errors.rb

@@ -0,0 +1,16 @@
+module Tabulous
+
+  class TabulousError < StandardError
+    def initialize(msg=nil)
+      msg = "Tabulous Error: #{msg}"
+      super
+    end
+  end
+
+  class ColumnError < TabulousError; end
+  class NoTabFoundError < TabulousError; end
+  class UnknownTabError < TabulousError; end
+  class TabNameError < TabulousError; end
+  class FormattingError < TabulousError; end
+
+end

data/lib/tabulous/formatter.rb

@@ -0,0 +1,278 @@
+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 = line.gsub(/\s/, '')
+      return line == 'config.tabs=[' || line == 'config.actions=['
+    end
+  
+    def end_of_table?
+      line = @line.split('#').first # naively strip out comments
+      return false if line.nil?
+      line = line.gsub(/\s/, '')
+      return line == ']'
+    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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,37 @@
+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 :raise_error_if_no_tab_found
+  @@raise_error_if_no_tab_found = true
+
+  mattr_accessor :css
+  @@css = Css.new
+
+  mattr_accessor :html5
+  @@html5 = false
+
+end

data/lib/tabulous/railtie.rb

@@ -0,0 +1,23 @@
+require 'tabulous'
+require 'rails'
+
+module Tabulous
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/tabulous.rake"
+    end
+    initializer 'tabulous.helper' do |app|  
+      ActionView::Base.send :include, Tabulous::Helpers
+    end
+    initializer 'tabulous.reload' do |app|
+      ActiveSupport.on_load(:action_controller) do
+        if Rails.env.development?
+          before_filter do
+            # reload tabulous initializer on every request if in development mode
+            load File.join(Rails.root.to_s, 'config/initializers/tabulous.rb')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tabulous/tab.rb

@@ -0,0 +1,79 @@
+module Tabulous
+
+  class Tab
+    
+    attr_reader :name, :parent
+    attr_accessor :subtabs
+    
+    def initialize(name, text, path, visible, enabled)
+      @name = name
+      name = name.to_s
+      if name.ends_with? '_tab'
+        @kind = :tab
+      elsif name.ends_with? '_subtab'
+        @kind = :subtab
+      else
+        raise TabNameError,
+              "Incorrect tab name: '#{name}'.  Tab names must end with _tab or _subtab."
+      end
+      @text = text
+      @path = path
+      @visible = visible
+      @enabled = enabled
+      @subtabs = []
+    end
+    
+    def add_parent(tab)
+      @parent = tab
+      @parent.subtabs = @parent.subtabs + [self]
+    end
+    
+    def subtab?
+      @kind == :subtab
+    end
+    
+    def text(view)
+      if @text.is_a? Proc
+        run_closure(view, @text)
+      else
+        @text
+      end
+    end
+    
+    def path(view)
+      if @path.is_a? Proc
+        run_closure(view, @path)
+      else
+        @path
+      end
+    end
+    
+    def visible?(view)
+      if @visible.is_a? Proc
+        !!run_closure(view, @visible)
+      else
+        !!@visible
+      end
+    end
+    
+    def enabled?(view)
+      if @enabled.is_a? Proc
+        !!run_closure(view, @enabled)
+      else
+        !!@enabled
+      end
+    end
+
+    private
+
+    def run_closure(view, closure)
+      if view.respond_to? :instance_exec
+        view.instance_exec(&closure) # for Ruby 1.9
+      else
+        view.instance_eval(&closure)
+      end
+    end
+
+  end
+
+end