tabulous 1.3.2 → 2.0.0

data/lib/tabulous/renderers/default_renderer.rb

@@ -0,0 +1,50 @@
+require 'active_support/core_ext/string'
+
+module Tabulous
+  class DefaultRenderer < SplitRenderer
+
+    def tabs_html
+      <<-HTML.strip_heredoc
+        <div class="tabs">
+          <ul>
+            #{ tab_list_html }
+          </ul>
+        </div>
+      HTML
+    end
+
+    def subtabs_html
+      <<-HTML.strip_heredoc
+        <div class="subtabs">
+          <ul>
+            #{ subtab_list_html }
+          </ul>
+        </div>
+      HTML
+    end
+
+  protected
+
+    def tab_html(tab)
+      return '' unless tab.visible?(@view)
+      html = ''
+      klass = ''
+      klass << 'active' if tab.active?(@view)
+      klass << ' disabled' unless tab.enabled?(@view)
+      klass.strip!
+      if klass.empty?
+        html << '<li>'
+      else
+        html << %Q{<li class="#{klass}">}
+      end
+      if tab.clickable?(@view)
+        html << %Q{<a href="#{tab.link_path(@view)}" class="tab">#{tab.text(@view)}</a>}
+      else
+        html << %Q{<span class="tab">#{tab.text(@view)}</span>}
+      end
+      html << "</li>"
+      html
+    end
+
+  end
+end

data/lib/tabulous/renderers/html5_renderer.rb

@@ -0,0 +1,25 @@
+module Tabulous
+  class Html5Renderer < DefaultRenderer
+
+    def tabs_html
+      <<-HTML.strip_heredoc
+        <nav class="tabs">
+          <ul>
+            #{ tab_list_html }
+          </ul>
+        </nav>
+      HTML
+    end
+
+    def subtabs_html
+      <<-HTML.strip_heredoc
+        <nav class="subtabs">
+          <ul>
+            #{ subtab_list_html }
+          </ul>
+        </nav>
+      HTML
+    end
+
+  end
+end

data/lib/tabulous/renderers/split_renderer.rb

@@ -0,0 +1,54 @@
+# A "split" renderer is one that produces two different HTML fragments:
+# one for the tabs, another for the subtabs.
+#
+# "Combined" renderers would embed the subtab HTML straight into the HTML for
+# the tabs, producing just one HTML fragment.
+#
+# This class is meant to be subclassed.  It encapsulates the code
+# common to all split renderers so that it doesn't have to be recoded
+# everytime.
+
+module Tabulous
+  class SplitRenderer
+
+    def initialize(tabset, view)
+      @view = view
+      @tabset = tabset
+    end
+
+    def tabs_html
+      raise "override me"
+    end
+
+    def subtabs_html
+      raise "override me"
+    end
+
+  protected
+
+    def tab_html(tab)
+      raise "override me"
+    end
+
+    def tab_list_html
+      html = ''
+      for tab in @tabset.primary_tabs
+        html << tab_html(tab)
+      end
+      html
+    end
+
+    def subtab_list_html
+      html = ''
+      for tab in subtabs
+        html << tab_html(tab)
+      end
+      html
+    end
+
+    def subtabs
+      @tabset.visible_subtabs(@view)
+    end
+
+  end
+end

data/lib/tabulous/rendering_coordinator.rb

@@ -0,0 +1,61 @@
+# The RenderingCoordinator gets called from the tabs or subtabs helper
+# in the view and delegates to a renderer object, which produces the
+# appropriate HTML.
+#
+# The RenderingCoordinator picks the appropriate rendering class to use
+# based on the renderer named in the Tabulous setup file.
+#
+# The RenderingCoordinator is not responsible for generating any HTML itself,
+# but is responsible for the algorithm of how the HTML gets generated.
+# For example, it adds CSS scaffolding if needed, and behaves according to
+# the value of the when_action_has_no_tab setting in the Tabulous setup file.
+#
+# This keeps renderer classes from having to focus on the behavior of rendering
+# as specified in the Tabulous setup file and instead renderer classes can
+# focus on producing HTML.
+
+module Tabulous
+  class RenderingCoordinator
+
+    def initialize(tabset, view)
+      @view = view
+      @tabset = tabset
+      begin
+        @renderer = "Tabulous::#{Config.renderer.to_s.camelize}Renderer".constantize.new(tabset, view)
+      rescue NameError
+        @renderer = "#{Config.renderer.to_s.camelize}Renderer".constantize.new(tabset, view)
+      end
+    end
+
+    def render_tabs
+      return if check_for_active_tab == :do_not_render
+      html = ''
+      html << CssScaffolding.embeddable_styles if Config.use_css_scaffolding
+      html << @renderer.tabs_html
+      @view.raw(html)
+    end
+
+    def render_subtabs
+      return if check_for_active_tab == :do_not_render
+      return '' if @tabset.visible_subtabs(@view).empty? && !Config.render_subtabs_when_empty
+      html = ''
+      html << @renderer.subtabs_html
+      @view.raw(html)
+    end
+
+  private
+
+    def check_for_active_tab
+      if !@tabset.active_primary_tab(@view)
+        if Config.when_action_has_no_tab == :raise_error
+          msg = "No tab is defined for the action '#{@view.action_name}' in the controller '#{@view.controller_path}'."
+          msg << " One of your tabs should have a valid active_when declaration that hooks it up to this controller action."
+          raise NoTabFoundError, msg
+        else
+          return Config.when_action_has_no_tab
+        end
+      end
+    end
+
+  end
+end

data/lib/tabulous/tab.rb

@@ -1,53 +1,110 @@
 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
+
+    attr_reader :parent
+    attr_accessor :subtabs, :kind, :name, :declared_to_have_subtabs
+    attr_writer :text, :link_path, :visible_when, :enabled_when
+
+    def initialize
       @subtabs = []
+      @active_actions = {}
+      @kind = :primary_tab
+      @declared_to_have_subtabs = false
     end
-    
-    def add_parent(tab)
+
+    def parent=(tab)
+      raise "only subtabs can have parents" unless subtab?
       @parent = tab
       @parent.subtabs = @parent.subtabs + [self]
     end
-    
+
     def subtab?
       @kind == :subtab
     end
-    
-    def text(view)
-      @text
+
+    def text(view=nil)
+      value = if @text.respond_to?(:call)
+        view.instance_exec(&@text)
+      else
+        @text
+      end
+      unless value.is_a?(String)
+        raise ImproperValueError, "The text of tab '#{self.name}' needs to be a string."
+      end
+      value
     end
-    
-    def path(view)
-      @path
+
+    def link_path(view=nil)
+      value = if @link_path.respond_to?(:call)
+        view.instance_exec(&@link_path)
+      else
+        @link_path
+      end
+      unless value.is_a?(String)
+        raise ImproperValueError, "The link_path of tab '#{self.name}' needs to be a string."
+      end
+      value
     end
-    
-    def visible?(view)
-      !!@visible
+
+    def visible?(view=nil)
+      if @visible_when.respond_to?(:call)
+        view.instance_exec(&@visible_when)
+      else
+        @visible_when
+      end
     end
-    
-    def enabled?(view)
-      !!@enabled
+
+    def enabled?(view=nil)
+      if @enabled_when.respond_to?(:call)
+        view.instance_exec(&@enabled_when)
+      else
+        @enabled_when
+      end
     end
 
-  end
+    def clickable?(view)
+      enabled?(view) && (!active?(view) || Config.active_tab_clickable)
+    end
 
+    # controller actions that make this tab active
+    def add_active_actions(controller, actions)
+      controller = controller.to_s
+      actions = [actions] if !actions.is_a?(Array)
+      for action in actions
+        @active_actions[controller] ||= []
+        @active_actions[controller] << action.to_s
+      end
+    end
+
+    def active?(view)
+      current_controller = view.controller_path.to_s
+      current_action = view.action_name.to_s
+      active_actions = @active_actions[current_controller]
+      return true if active_actions && (active_actions.include?('any') || active_actions.include?(current_action))
+      return true if @subtabs.any? { |subtab| subtab.active?(view) }
+      false
+    end
+
+    def active_actions_overlap?(tab)
+      for controller in @active_actions.keys
+        other_actions = tab.active_actions[controller]
+        if other_actions
+          these_actions = @active_actions[controller]
+          if (!(other_actions & these_actions).empty?) ||
+             other_actions.include?('any') ||
+             these_actions.include?('any')
+            return true
+          end
+        end
+      end
+      false
+    end
+
+  protected
+
+    def active_actions
+      @active_actions
+    end
+
+  end
 end

data/lib/tabulous/tabset.rb

@@ -0,0 +1,39 @@
+module Tabulous
+  class Tabset
+
+    def initialize
+      @tabs = []
+    end
+
+    def add_tab(tab)
+      if @tabs.map(&:name).include?(tab.name)
+        raise TabNameError, "There is already a tab named '#{tab.name}'."
+      end
+      @tabs << tab
+    end
+
+    def tabs
+      @tabs
+    end
+
+    def primary_tabs
+      @tabs.reject(&:subtab?)
+    end
+
+    def active_primary_tab(view)
+      for tab in primary_tabs
+        return tab if tab.active?(view)
+      end
+      nil
+    end
+
+    def visible_subtabs(view)
+      if active_primary_tab(view).nil?
+        []
+      else
+        active_primary_tab(view).subtabs.select{|subtab| subtab.visible?(view)}
+      end
+    end
+
+  end
+end

data/lib/tabulous/tabsets.rb

@@ -0,0 +1,18 @@
+module Tabulous
+  class Tabsets
+
+    class << self
+
+      def add(tabset_name, tabset)
+        @tabsets ||= {}
+        @tabsets[tabset_name.to_s] = tabset
+      end
+
+      def get(tabset_name)
+        @tabsets[tabset_name.to_s]
+      end
+
+    end
+
+  end
+end

data/lib/tabulous/tabulous.rb

@@ -1,247 +1,7 @@
 module Tabulous
-
-  def self.setup
-    yield self
-  end
-  
-  def self.tabs(&block)
-    @@tabs_block = block
-  end
-
-  def self.actions(&block)
-    @@actions_block = block
-  end
-
-  def self.render_tabs(view)
-    initialize_tabs(view)
-    return if !tab_defined?(view) && @@when_action_has_no_tab == :do_not_render
-    html = ''
-    html << embed_styles
-    active_tab = active_tab(view)
-    active_tab_name = (active_tab ? active_tab.name : nil);
-    html << (@@html5 ? '<nav id="tabs">' : '<div id="tabs">')
-    if @@tabs_ul_class
-      html << %Q{<ul class="#{@@tabs_ul_class}">}
-    else
-      html << '<ul>'
-    end
-    for tab in main_tabs
-      next if !tab.visible?(view)
-      if @@bootstrap_style_subtabs
-        subtabs = tab.subtabs.select{|subtab| subtab.visible?(view)}
-      end
-      if @@bootstrap_style_subtabs && !subtabs.empty?
-        html << render_dropdown_tab(view,
-                                    :text => tab.text(view),
-                                    :path => tab.path(view),
-                                    :active => (active_tab_name && tab.name == active_tab_name),
-                                    :enabled => tab.enabled?(view),
-                                    :subtabs => subtabs)
-      else
-        html << render_tab(:text => tab.text(view),
-                           :path => tab.path(view),
-                           :active => (active_tab_name && tab.name == active_tab_name),
-                           :enabled => tab.enabled?(view))
-      end
-    end
-    html << '</ul>'
-    html << (@@html5 ? '</nav>' : '</div>')
-    view.raw(html)
-  end
-  
-  def self.render_subtabs(view)
-    if @@bootstrap_style_subtabs
-      raise TabulousError,
-            "You should not call the subtabs view helper when config.bootstrap_style_subtabs " +
-            "is set to true.  Simply call the tabs helper and the subtabs will be " +
-            "automatically rendered."
-    end
-    initialize_tabs(view)
-    return if !tab_defined?(view) && @@when_action_has_no_tab == :do_not_render
-    controller = view.controller_name.to_sym
-    action = view.action_name.to_sym
-    tab = active_tab(view)
-    html = ''
-    html << (@@html5 ? '<nav id="subtabs">' : '<div id="subtabs">')
-    if @@subtabs_ul_class
-      html << %Q{<ul class="#{@@subtabs_ul_class}">}
-    else
-      html << '<ul>'
-    end
-    if tab.nil?
-      subtabs = []
-    else
-      subtabs = tab.subtabs.select{|subtab| subtab.visible?(view)}
-    end
-    return if subtabs.empty? && !@@always_render_subtabs
-    for subtab in subtabs
-      html << render_tab(:text => subtab.text(view),
-                         :path => subtab.path(view),
-                         :active => active?(controller, action, subtab.name),
-                         :enabled => subtab.enabled?(view))
-    end
-    html << '</ul>'
-    html << (@@html5 ? '</nav>' : '</div>')
-    view.raw(html)
-  end
-
-  def self.render_tab(options)
-    html = ''
-    klass = (options[:active] ? 'active' : 'inactive')
-    klass << (options[:enabled] ? ' enabled' : ' disabled')
-    html << %Q{<li class="#{klass}">}
-    if (options[:active] && !@@active_tab_clickable) || options[:enabled] == false
-      html << %Q{<span class="tab">#{options[:text]}</span>}
-    else
-      html << %Q{<a href="#{options[:path]}" class="tab">#{options[:text]}</a>}
-    end
-    html << '</li>'
-    html
-  end
-
-  # markup spefically tailored for Twitter Bootstrap
-  def self.render_dropdown_tab(view, options)
-    html = ''
-    klass = 'dropdown'
-    klass << (options[:active] ? ' active' : ' inactive')
-    klass << (options[:enabled] ? ' enabled' : ' disabled')
-    html << %Q{<li class="#{klass}">}
-    if (options[:active] && !@@active_tab_clickable) || options[:enabled] == false
-      html << %Q{<span class="tab">#{options[:text]}</span>}
-    else
-      html << %Q{<a class="dropdown-toggle tab"}
-      html << %Q{   data-toggle="dropdown"}
-      html << %Q{   href="#">}
-      html << %Q{#{options[:text]}<b class="caret"></b></a>}
-    end
-    if @@subtabs_ul_class
-      html << %Q{<ul class="dropdown-menu #{@@subtabs_ul_class}">}
-    else
-      html << '<ul class="dropdown-menu">'
-    end
-    for subtab in options[:subtabs]
-      if subtab.enabled?(view)
-        html << '<li class="enabled">'
-      else
-        html << '<li class="disabled">'
-      end
-      html << %Q{<a href="#{subtab.path(view)}">#{subtab.text(view)}</a>}
-      html << '</li>'
-    end
-    html << '</ul>'
-    html << '</li>'
-    html
-  end
-
-  def self.initialize_tabs(view)
-    if view.respond_to? :instance_exec # for Ruby 1.9
-      self.tabs = view.instance_exec(&@@tabs_block)
-      self.actions = view.instance_exec(&@@actions_block)
-    else
-      self.tabs = view.instance_eval(&@@tabs_block)
-      self.actions = view.instance_eval(&@@actions_block)
-    end
-  end
-
-  def self.tabs=(ary)
-    @@tabs = []
-    last_tab = nil
-    ary.each do |tab_args|
-      begin
-        tab = Tab.new(*tab_args)
-      rescue ArgumentError
-        raise ColumnError,
-              "Your config.tabs table is improperly formatted.  You probably have " +
-              "the wrong number of columns.  Or, in other words, one of the arrays " +
-              "in the config.tabs array has the wrong number of elements."
-      end
-      if tab.subtab?
-        tab.add_parent(last_tab)
-      else
-        last_tab = tab
-      end
-      @@tabs << tab
-    end
-  end
-  
-  def self.actions=(ary)
-    @@actions = {}
-    ary.each do |a|
-      if a.size != 3
-        raise ColumnError,
-              "Your config.actions table is improperly formatted.  You probably have " +
-              "the wrong number of columns.  Or, in other words, one of the arrays " +
-              "in the config.actions array has the wrong number of elements."
-      end
-    end
-    ary.each do |controller, action, tab|
-      @@actions[controller] ||= {}
-      @@actions[controller][action] ||= []
-      @@actions[controller][action] << tab
-    end
-  end
-  
-  def self.main_tabs
-    @@tabs.select { |t| !t.subtab? }
-  end
-  
-  def self.active_tab(view)
-    controller = view.controller_name.to_sym
-    action = view.action_name.to_sym
-    for tab in @@tabs
-      if active?(controller, action, tab.name)
-        if tab.subtab?
-          return tab.parent
-        else
-          return tab
-        end
-      end
-    end
-    nil
-  end
-
-  def self.active?(controller, action, tab_name)
-    return false if @@actions[controller].nil?
-    (@@actions[controller][action] && @@actions[controller][action].include?(tab_name)) ||
-    (@@actions[controller][:all_actions] && @@actions[controller][:all_actions].include?(tab_name))
-  end
-
-  def self.tab_defined?(view)
-    controller = view.controller_name.to_sym
-    action = view.action_name.to_sym
-    if @@actions[controller].nil?
-      if @@when_action_has_no_tab == :raise_error
-        raise NoTabFoundError,
-              "No tabs are defined for the controller '#{controller}'.  " +
-              "You can define a tab for this controller in app/tabs/tabulous.rb " +
-              "in the 'config.actions =' section.  You can also turn off NoTabFoundErrors " +
-              "by changing the value of config.when_action_has_no_tab."
-      else
-        return false
-      end
-    end
-    if @@actions[controller][action].nil? && !@@actions[controller][:all_actions]
-      if @@when_action_has_no_tab == :raise_error
-        raise NoTabFoundError,
-              "No tab is defined for the action '#{action}' in the controller '#{controller}'.  " +
-              "You can define a tab for this action in app/tabs/tabulous.rb " +
-              "in the 'config.actions =' section.  You can also turn off NoTabFoundErrors " +
-              "by changing the value of config.when_action_has_no_tab."
-      else
-        return false
-      end
-    end
-    tab = active_tab(view)
-    if tab.nil?
-      alleged_tab = @@actions[controller][action]
-      if alleged_tab.nil?
-        alleged_tab = @@actions[controller][:all_actions]
-      end
-      raise UnknownTabError,
-            "You've hooked the action '#{action}' in controller '#{controller}' to " +
-            "the tab '#{alleged_tab}', but this tab is not defined."
+  class << self
+    def setup(&block)
+      Dsl::Setup.process(&block)
     end
-    true
   end
-
 end

data/lib/tabulous/version.rb

@@ -1,3 +1,3 @@
 module Tabulous
-  VERSION = "1.3.2"
+  VERSION = "2.0.0"
 end

data/lib/tabulous/view_helpers.rb

@@ -0,0 +1,13 @@
+module Tabulous
+  module ViewHelpers
+
+    def tabs(tabset_name = :default)
+      RenderingCoordinator.new(Tabsets.get(tabset_name), self).render_tabs
+    end
+
+    def subtabs(tabset_name = :default)
+      RenderingCoordinator.new(Tabsets.get(tabset_name), self).render_subtabs
+    end
+
+  end
+end

data/lib/tabulous.rb

@@ -3,9 +3,22 @@ module Tabulous
 end
 
 require 'tabulous/errors'
-require 'tabulous/options'
+require 'tabulous/old_version_checker'
+require 'tabulous/tabsets'
+require 'tabulous/view_helpers'
 require 'tabulous/css_scaffolding'
-require 'tabulous/helpers'
-require 'tabulous/formatter'
+require 'tabulous/config'
 require 'tabulous/tab'
+require 'tabulous/tabset'
+require 'tabulous/dsl/config'
+require 'tabulous/dsl/tab'
+require 'tabulous/dsl/tabs'
+require 'tabulous/dsl/setup'
+require 'tabulous/rendering_coordinator'
+require 'tabulous/renderers/split_renderer'
+require 'tabulous/renderers/combined_renderer'
+require 'tabulous/renderers/default_renderer'
+require 'tabulous/renderers/html5_renderer'
+require 'tabulous/renderers/bootstrap_renderer'
+require 'tabulous/renderers/bootstrap_pill_renderer'
 require 'tabulous/tabulous'