semantic-ui-sass 0.19.3.1 → 1.7.0.0

data/app/assets/javascripts/semantic-ui/tab.js

@@ -1,6 +1,7 @@
-/*
+ /*
  * # Semantic - Tab
- * http://github.com/jlukic/semantic-ui/
+ * http://github.com/semantic-org/semantic-ui/
+ *
  *
  * Copyright 2014 Contributors
  * Released under the MIT license
@@ -8,703 +9,779 @@
  *
  */
 
-
 ;(function ($, window, document, undefined) {
 
-  $.fn.tab = function(parameters) {
+"use strict";
 
-    var
-      settings        = $.extend(true, {}, $.fn.tab.settings, parameters),
+$.fn.tab = function(parameters) {
 
-      $module         = $(this),
-      $tabs           = $(settings.context).find(settings.selector.tabs),
+  var
+    // use window context if none specified
+    $allModules     = $.isFunction(this)
+        ? $(window)
+        : $(this),
 
-      moduleSelector  = $module.selector || '',
+    settings        = ( $.isPlainObject(parameters) )
+      ? $.extend(true, {}, $.fn.tab.settings, parameters)
+      : $.extend({}, $.fn.tab.settings),
 
-      cache           = {},
-      firstLoad       = true,
-      recursionDepth  = 0,
+    moduleSelector  = $allModules.selector || '',
+    time            = new Date().getTime(),
+    performance     = [],
 
-      activeTabPath,
-      parameterArray,
-      historyEvent,
+    query           = arguments[0],
+    methodInvoked   = (typeof query == 'string'),
+    queryArguments  = [].slice.call(arguments, 1),
 
-      element         = this,
-      time            = new Date().getTime(),
-      performance     = [],
+    module,
+    returnedValue
+  ;
 
-      className       = settings.className,
-      metadata        = settings.metadata,
-      error           = settings.error,
+  $allModules
+    .each(function() {
+      var
 
-      eventNamespace  = '.' + settings.namespace,
-      moduleNamespace = 'module-' + settings.namespace,
+        className          = settings.className,
+        metadata           = settings.metadata,
+        selector           = settings.selector,
+        error              = settings.error,
 
-      instance        = $module.data(moduleNamespace),
+        eventNamespace     = '.' + settings.namespace,
+        moduleNamespace    = 'module-' + settings.namespace,
 
-      query           = arguments[0],
-      methodInvoked   = (instance !== undefined && typeof query == 'string'),
-      queryArguments  = [].slice.call(arguments, 1),
+        $module            = $(this),
 
-      module,
-      returnedValue
-    ;
+        cache              = {},
+        firstLoad          = true,
+        recursionDepth     = 0,
 
-    module = {
+        $context,
+        $tabs,
+        activeTabPath,
+        parameterArray,
+        historyEvent,
 
-      initialize: function() {
-        module.debug('Initializing Tabs', $module);
+        element         = this,
+        instance        = $module.data(moduleNamespace)
+      ;
 
-        // set up automatic routing
-        if(settings.auto) {
-          module.verbose('Setting up automatic tab retrieval from server');
-          settings.apiSettings = {
-            url: settings.path + '/{$tab}'
-          };
-        }
+      module = {
+
+        initialize: function() {
+          module.debug('Initializing tab menu item', $module);
 
-        // attach history events
-        if(settings.history) {
-          module.debug('Initializing page state');
-          if( $.address === undefined ) {
-            module.error(error.state);
-            return false;
+          module.determineTabs();
+          module.debug('Determining tabs', settings.context, $tabs);
+
+          // set up automatic routing
+          if(settings.auto) {
+            module.verbose('Setting up automatic tab retrieval from server');
+            settings.apiSettings = {
+              url: settings.path + '/{$tab}'
+            };
           }
-          else {
-            if(settings.historyType == 'hash') {
-              module.debug('Using hash state change to manage state');
-            }
-            if(settings.historyType == 'html5') {
-              module.debug('Using HTML5 to manage state');
-              if(settings.path !== false) {
-                $.address
-                  .history(true)
-                  .state(settings.path)
-                ;
-              }
-              else {
-                module.error(error.path);
-                return false;
-              }
-            }
-            $.address
-              .unbind('change')
-              .bind('change', module.event.history.change)
+
+          // attach events if navigation wasn't set to window
+          if( !$.isWindow( element ) ) {
+            module.debug('Attaching tab activation events to element', $module);
+            $module
+              .on('click' + eventNamespace, module.event.click)
             ;
           }
-        }
+          module.instantiate();
+        },
 
-        // attach events if navigation wasn't set to window
-        if( !$.isWindow( element ) ) {
-          module.debug('Attaching tab activation events to element', $module);
-          $module
-            .on('click' + eventNamespace, module.event.click)
-          ;
-        }
-        module.instantiate();
-      },
-
-      instantiate: function () {
-        module.verbose('Storing instance of module', module);
-        $module
-          .data(moduleNamespace, module)
-        ;
-      },
-
-      destroy: function() {
-        module.debug('Destroying tabs', $module);
-        $module
-          .removeData(moduleNamespace)
-          .off(eventNamespace)
-        ;
-      },
-
-      event: {
-        click: function(event) {
+        determineTabs: function() {
           var
-            tabPath = $(this).data(metadata.tab)
+            $reference
           ;
-          if(tabPath !== undefined) {
-            if(settings.history) {
-              module.verbose('Updating page state', event);
-              $.address.value(tabPath);
+
+          // determine tab context
+          if(settings.context === 'parent') {
+            if($module.closest(selector.ui).size() > 0) {
+              $reference = $module.closest(selector.ui);
+              module.verbose('Using closest UI element for determining parent', $reference);
             }
             else {
-              module.verbose('Changing tab without state management', event);
-              module.changeTab(tabPath);
+              $reference = $module;
             }
-            event.preventDefault();
+            $context = $reference.parent();
+            module.verbose('Determined parent element for creating context', $context);
+          }
+          else if(settings.context) {
+            $context = $(settings.context);
+            module.verbose('Using selector for tab context', settings.context, $context);
+          }
+          else {
+            $context = $('body');
+          }
+
+          // find tabs
+          if(settings.childrenOnly) {
+            $tabs = $context.children(selector.tabs);
+            module.debug('Searching tab context children for tabs', $context, $tabs);
           }
           else {
-            module.debug('No tab specified');
+            $tabs = $context.find(selector.tabs);
+            module.debug('Searching tab context for tabs', $context, $tabs);
           }
         },
-        history: {
-          change: function(event) {
+
+        initializeHistory: function() {
+          if(settings.history) {
+            module.debug('Initializing page state');
+            if( $.address === undefined ) {
+              module.error(error.state);
+              return false;
+            }
+            else {
+              if(settings.historyType == 'state') {
+                module.debug('Using HTML5 to manage state');
+                if(settings.path !== false) {
+                  $.address
+                    .history(true)
+                    .state(settings.path)
+                  ;
+                }
+                else {
+                  module.error(error.path);
+                  return false;
+                }
+              }
+              $.address
+                .bind('change', module.event.history.change)
+              ;
+            }
+          }
+        },
+
+        instantiate: function () {
+          module.verbose('Storing instance of module', module);
+          instance = module;
+          $module
+            .data(moduleNamespace, module)
+          ;
+        },
+
+        destroy: function() {
+          module.debug('Destroying tabs', $module);
+          $module
+            .removeData(moduleNamespace)
+            .off(eventNamespace)
+          ;
+        },
+
+        event: {
+          click: function(event) {
             var
-              tabPath   = event.pathNames.join('/') || module.get.initialPath(),
-              pageTitle = settings.templates.determineTitle(tabPath) || false
+              tabPath = $(this).data(metadata.tab)
             ;
-            module.debug('History change event', tabPath, event);
-            historyEvent = event;
             if(tabPath !== undefined) {
-              module.changeTab(tabPath);
+              if(settings.history) {
+                module.verbose('Updating page state', event);
+                $.address.value(tabPath);
+              }
+              else {
+                module.verbose('Changing tab', event);
+                module.changeTab(tabPath);
+              }
+              event.preventDefault();
+            }
+            else {
+              module.debug('No tab specified');
             }
-            if(pageTitle) {
-              $.address.title(pageTitle);
+          },
+          history: {
+            change: function(event) {
+              var
+                tabPath   = event.pathNames.join('/') || module.get.initialPath(),
+                pageTitle = settings.templates.determineTitle(tabPath) || false
+              ;
+              module.performance.display();
+              module.debug('History change event', tabPath, event);
+              historyEvent = event;
+              if(tabPath !== undefined) {
+                module.changeTab(tabPath);
+              }
+              if(pageTitle) {
+                $.address.title(pageTitle);
+              }
             }
           }
-        }
-      },
+        },
 
-      refresh: function() {
-        if(activeTabPath) {
-          module.debug('Refreshing tab', activeTabPath);
-          module.changeTab(activeTabPath);
-        }
-      },
+        refresh: function() {
+          if(activeTabPath) {
+            module.debug('Refreshing tab', activeTabPath);
+            module.changeTab(activeTabPath);
+          }
+        },
 
-      cache: {
+        cache: {
 
-        read: function(cacheKey) {
-          return (cacheKey !== undefined)
-            ? cache[cacheKey]
-            : false
-          ;
+          read: function(cacheKey) {
+            return (cacheKey !== undefined)
+              ? cache[cacheKey]
+              : false
+            ;
+          },
+          add: function(cacheKey, content) {
+            cacheKey = cacheKey || activeTabPath;
+            module.debug('Adding cached content for', cacheKey);
+            cache[cacheKey] = content;
+          },
+          remove: function(cacheKey) {
+            cacheKey = cacheKey || activeTabPath;
+            module.debug('Removing cached content for', cacheKey);
+            delete cache[cacheKey];
+          }
         },
-        add: function(cacheKey, content) {
-          cacheKey = cacheKey || activeTabPath;
-          module.debug('Adding cached content for', cacheKey);
-          cache[cacheKey] = content;
+
+        set: {
+          state: function(state) {
+            $.address.value(state);
+          }
         },
-        remove: function(cacheKey) {
-          cacheKey = cacheKey || activeTabPath;
-          module.debug('Removing cached content for', cacheKey);
-          delete cache[cacheKey];
-        }
-      },
 
-      set: {
-        state: function(url) {
-          $.address.value(url);
-        }
-      },
-
-      changeTab: function(tabPath) {
-        var
-          pushStateAvailable = (window.history && window.history.pushState),
-          shouldIgnoreLoad   = (pushStateAvailable && settings.ignoreFirstLoad && firstLoad),
-          remoteContent      = (settings.auto || $.isPlainObject(settings.apiSettings) ),
-          // only get default path if not remote content
-          pathArray = (remoteContent && !shouldIgnoreLoad)
-            ? module.utilities.pathToArray(tabPath)
-            : module.get.defaultPathArray(tabPath)
-        ;
-        tabPath = module.utilities.arrayToPath(pathArray);
-        module.deactivate.all();
-        $.each(pathArray, function(index, tab) {
+        changeTab: function(tabPath) {
           var
-            currentPathArray   = pathArray.slice(0, index + 1),
-            currentPath        = module.utilities.arrayToPath(currentPathArray),
+            pushStateAvailable = (window.history && window.history.pushState),
+            shouldIgnoreLoad   = (pushStateAvailable && settings.ignoreFirstLoad && firstLoad),
+            remoteContent      = (settings.auto || $.isPlainObject(settings.apiSettings) ),
+            // only get default path if not remote content
+            pathArray = (remoteContent && !shouldIgnoreLoad)
+              ? module.utilities.pathToArray(tabPath)
+              : module.get.defaultPathArray(tabPath)
+          ;
+          tabPath = module.utilities.arrayToPath(pathArray);
+          $.each(pathArray, function(index, tab) {
+            var
+              currentPathArray   = pathArray.slice(0, index + 1),
+              currentPath        = module.utilities.arrayToPath(currentPathArray),
 
-            isTab              = module.is.tab(currentPath),
-            isLastIndex        = (index + 1 == pathArray.length),
+              isTab              = module.is.tab(currentPath),
+              isLastIndex        = (index + 1 == pathArray.length),
 
-            $tab               = module.get.tabElement(currentPath),
-            nextPathArray,
-            nextPath,
-            isLastTab
-          ;
-          module.verbose('Looking for tab', tab);
-          if(isTab) {
-            module.verbose('Tab was found', tab);
+              $tab               = module.get.tabElement(currentPath),
+              $anchor,
+              nextPathArray,
+              nextPath,
+              isLastTab
+            ;
+            module.verbose('Looking for tab', tab);
+            if(isTab) {
+              module.verbose('Tab was found', tab);
 
-            // scope up
-            activeTabPath = currentPath;
-            parameterArray = module.utilities.filterArray(pathArray, currentPathArray);
+              // scope up
+              activeTabPath = currentPath;
+              parameterArray = module.utilities.filterArray(pathArray, currentPathArray);
 
-            if(isLastIndex) {
-              isLastTab = true;
-            }
-            else {
-              nextPathArray = pathArray.slice(0, index + 2);
-              nextPath      = module.utilities.arrayToPath(nextPathArray);
-              isLastTab     = ( !module.is.tab(nextPath) );
-              if(isLastTab) {
-                module.verbose('Tab parameters found', nextPathArray);
+              if(isLastIndex) {
+                isLastTab = true;
               }
-            }
-            if(isLastTab && remoteContent) {
-              if(!shouldIgnoreLoad) {
-                module.activate.navigation(currentPath);
-                module.content.fetch(currentPath, tabPath);
+              else {
+                nextPathArray = pathArray.slice(0, index + 2);
+                nextPath      = module.utilities.arrayToPath(nextPathArray);
+                isLastTab     = ( !module.is.tab(nextPath) );
+                if(isLastTab) {
+                  module.verbose('Tab parameters found', nextPathArray);
+                }
+              }
+              if(isLastTab && remoteContent) {
+                if(!shouldIgnoreLoad) {
+                  module.activate.navigation(currentPath);
+                  module.content.fetch(currentPath, tabPath);
+                }
+                else {
+                  module.debug('Ignoring remote content on first tab load', currentPath);
+                  firstLoad = false;
+                  module.cache.add(tabPath, $tab.html());
+                  module.activate.all(currentPath);
+                  $.proxy(settings.onTabInit, $tab)(currentPath, parameterArray, historyEvent);
+                  $.proxy(settings.onTabLoad, $tab)(currentPath, parameterArray, historyEvent);
+                }
+                return false;
               }
               else {
-                module.debug('Ignoring remote content on first tab load', currentPath);
-                firstLoad = false;
-                module.cache.add(tabPath, $tab.html());
+                module.debug('Opened local tab', currentPath);
                 module.activate.all(currentPath);
-                $.proxy(settings.onTabInit, $tab)(currentPath, parameterArray, historyEvent);
+                if( !module.cache.read(currentPath) ) {
+                  module.cache.add(currentPath, true);
+                  module.debug('First time tab loaded calling tab init');
+                  $.proxy(settings.onTabInit, $tab)(currentPath, parameterArray, historyEvent);
+                }
                 $.proxy(settings.onTabLoad, $tab)(currentPath, parameterArray, historyEvent);
               }
-              return false;
             }
-            else {
-              module.debug('Opened local tab', currentPath);
-              module.activate.all(currentPath);
-              if( !module.cache.read(currentPath) ) {
-                module.cache.add(currentPath, true);
-                module.debug('First time tab loaded calling tab init');
-                $.proxy(settings.onTabInit, $tab)(currentPath, parameterArray, historyEvent);
+            else if(tabPath.search('/') == -1 && tabPath !== '') {
+              // look for in page anchor
+              $anchor     = $('#' + tabPath + ', a[name="' + tabPath + '"]'),
+              currentPath = $anchor.closest('[data-tab]').data('tab');
+              $tab        = module.get.tabElement(currentPath);
+              // if anchor exists use parent tab
+              if($anchor && $anchor.size() > 0 && currentPath) {
+                module.debug('No tab found, but deep anchor link present, opening parent tab');
+                module.activate.all(currentPath);
+                if( !module.cache.read(currentPath) ) {
+                  module.cache.add(currentPath, true);
+                  module.debug('First time tab loaded calling tab init');
+                  $.proxy(settings.onTabInit, $tab)(currentPath, parameterArray, historyEvent);
+                }
+                return false;
               }
-              $.proxy(settings.onTabLoad, $tab)(currentPath, parameterArray, historyEvent);
             }
-          }
-          else {
-            module.error(error.missingTab, tab);
-            return false;
-          }
-        });
-      },
+            else {
+              module.error(error.missingTab, $module, $context, currentPath);
+              return false;
+            }
+          });
+        },
 
-      content: {
+        content: {
 
-        fetch: function(tabPath, fullTabPath) {
-          var
-            $tab             = module.get.tabElement(tabPath),
-            apiSettings      = {
-              dataType     : 'html',
-              stateContext : $tab,
-              success      : function(response) {
-                module.cache.add(fullTabPath, response);
-                module.content.update(tabPath, response);
-                if(tabPath == activeTabPath) {
-                  module.debug('Content loaded', tabPath);
-                  module.activate.tab(tabPath);
-                }
-                else {
-                  module.debug('Content loaded in background', tabPath);
-                }
-                $.proxy(settings.onTabInit, $tab)(tabPath, parameterArray, historyEvent);
-                $.proxy(settings.onTabLoad, $tab)(tabPath, parameterArray, historyEvent);
+          fetch: function(tabPath, fullTabPath) {
+            var
+              $tab             = module.get.tabElement(tabPath),
+              apiSettings      = {
+                dataType     : 'html',
+                stateContext : $tab,
+                onSuccess      : function(response) {
+                  module.cache.add(fullTabPath, response);
+                  module.content.update(tabPath, response);
+                  if(tabPath == activeTabPath) {
+                    module.debug('Content loaded', tabPath);
+                    module.activate.tab(tabPath);
+                  }
+                  else {
+                    module.debug('Content loaded in background', tabPath);
+                  }
+                  $.proxy(settings.onTabInit, $tab)(tabPath, parameterArray, historyEvent);
+                  $.proxy(settings.onTabLoad, $tab)(tabPath, parameterArray, historyEvent);
+                },
+                urlData: { tab: fullTabPath }
               },
-              urlData: { tab: fullTabPath }
-            },
-            request         = $tab.data(metadata.promise) || false,
-            existingRequest = ( request && request.state() === 'pending' ),
-            requestSettings,
-            cachedContent
-          ;
+              request         = $tab.data(metadata.promise) || false,
+              existingRequest = ( request && request.state() === 'pending' ),
+              requestSettings,
+              cachedContent
+            ;
 
-          fullTabPath   = fullTabPath || tabPath;
-          cachedContent = module.cache.read(fullTabPath);
+            fullTabPath   = fullTabPath || tabPath;
+            cachedContent = module.cache.read(fullTabPath);
 
-          if(settings.cache && cachedContent) {
-            module.debug('Showing existing content', fullTabPath);
-            module.content.update(tabPath, cachedContent);
-            module.activate.tab(tabPath);
-            $.proxy(settings.onTabLoad, $tab)(tabPath, parameterArray, historyEvent);
-          }
-          else if(existingRequest) {
-            module.debug('Content is already loading', fullTabPath);
+            if(settings.cache && cachedContent) {
+              module.debug('Showing existing content', fullTabPath);
+              module.content.update(tabPath, cachedContent);
+              module.activate.tab(tabPath);
+              $.proxy(settings.onTabLoad, $tab)(tabPath, parameterArray, historyEvent);
+            }
+            else if(existingRequest) {
+              module.debug('Content is already loading', fullTabPath);
+              $tab
+                .addClass(className.loading)
+              ;
+            }
+            else if($.api !== undefined) {
+              requestSettings = $.extend(true, { headers: { 'X-Remote': true } }, settings.apiSettings, apiSettings);
+              module.debug('Retrieving remote content', fullTabPath, requestSettings);
+              $.api( requestSettings );
+            }
+            else {
+              module.error(error.api);
+            }
+          },
+
+          update: function(tabPath, html) {
+            module.debug('Updating html for', tabPath);
+            var
+              $tab = module.get.tabElement(tabPath)
+            ;
             $tab
-              .addClass(className.loading)
+              .html(html)
             ;
           }
-          else if($.api !== undefined) {
-            console.log(settings.apiSettings);
-            requestSettings = $.extend(true, { headers: { 'X-Remote': true } }, settings.apiSettings, apiSettings);
-            module.debug('Retrieving remote content', fullTabPath, requestSettings);
-            $.api( requestSettings );
-          }
-          else {
-            module.error(error.api);
-          }
         },
 
-        update: function(tabPath, html) {
-          module.debug('Updating html for', tabPath);
-          var
-            $tab = module.get.tabElement(tabPath)
-          ;
-          $tab
-            .html(html)
-          ;
-        }
-      },
-
-      activate: {
-        all: function(tabPath) {
-          module.activate.tab(tabPath);
-          module.activate.navigation(tabPath);
-        },
-        tab: function(tabPath) {
-          var
-            $tab = module.get.tabElement(tabPath)
-          ;
-          module.verbose('Showing tab content for', $tab);
-          $tab.addClass(className.active);
+        activate: {
+          all: function(tabPath) {
+            module.activate.tab(tabPath);
+            module.activate.navigation(tabPath);
+          },
+          tab: function(tabPath) {
+            var
+              $tab = module.get.tabElement(tabPath)
+            ;
+            module.verbose('Showing tab content for', $tab);
+            $tab
+              .addClass(className.active)
+              .siblings($tabs)
+                .removeClass(className.active + ' ' + className.loading)
+            ;
+          },
+          navigation: function(tabPath) {
+            var
+              $navigation = module.get.navElement(tabPath)
+            ;
+            module.verbose('Activating tab navigation for', $navigation, tabPath);
+            $navigation
+              .addClass(className.active)
+              .siblings($allModules)
+                .removeClass(className.active + ' ' + className.loading)
+            ;
+          }
         },
-        navigation: function(tabPath) {
-          var
-            $navigation = module.get.navElement(tabPath)
-          ;
-          module.verbose('Activating tab navigation for', $navigation, tabPath);
-          $navigation.addClass(className.active);
-        }
-      },
 
-      deactivate: {
-        all: function() {
-          module.deactivate.navigation();
-          module.deactivate.tabs();
-        },
-        navigation: function() {
-          $module
-            .removeClass(className.active)
-          ;
+        deactivate: {
+          all: function() {
+            module.deactivate.navigation();
+            module.deactivate.tabs();
+          },
+          navigation: function() {
+            $allModules
+              .removeClass(className.active)
+            ;
+          },
+          tabs: function() {
+            $tabs
+              .removeClass(className.active + ' ' + className.loading)
+            ;
+          }
         },
-        tabs: function() {
-          $tabs
-            .removeClass(className.active + ' ' + className.loading)
-          ;
-        }
-      },
-
-      is: {
-        tab: function(tabName) {
-          return (tabName !== undefined)
-            ? ( module.get.tabElement(tabName).size() > 0 )
-            : false
-          ;
-        }
-      },
 
-      get: {
-        initialPath: function() {
-          return $module.eq(0).data(metadata.tab) || $tabs.eq(0).data(metadata.tab);
-        },
-        path: function() {
-          return $.address.value();
-        },
-        // adds default tabs to tab path
-        defaultPathArray: function(tabPath) {
-          return module.utilities.pathToArray( module.get.defaultPath(tabPath) );
+        is: {
+          tab: function(tabName) {
+            return (tabName !== undefined)
+              ? ( module.get.tabElement(tabName).size() > 0 )
+              : false
+            ;
+          }
         },
-        defaultPath: function(tabPath) {
-          var
-            $defaultNav = $module.filter('[data-' + metadata.tab + '^="' + tabPath + '/"]').eq(0),
-            defaultTab  = $defaultNav.data(metadata.tab) || false
-          ;
-          if( defaultTab ) {
-            module.debug('Found default tab', defaultTab);
-            if(recursionDepth < settings.maxDepth) {
-              recursionDepth++;
-              return module.get.defaultPath(defaultTab);
+
+        get: {
+          initialPath: function() {
+            return $allModules.eq(0).data(metadata.tab) || $tabs.eq(0).data(metadata.tab);
+          },
+          path: function() {
+            return $.address.value();
+          },
+          // adds default tabs to tab path
+          defaultPathArray: function(tabPath) {
+            return module.utilities.pathToArray( module.get.defaultPath(tabPath) );
+          },
+          defaultPath: function(tabPath) {
+            var
+              $defaultNav = $allModules.filter('[data-' + metadata.tab + '^="' + tabPath + '/"]').eq(0),
+              defaultTab  = $defaultNav.data(metadata.tab) || false
+            ;
+            if( defaultTab ) {
+              module.debug('Found default tab', defaultTab);
+              if(recursionDepth < settings.maxDepth) {
+                recursionDepth++;
+                return module.get.defaultPath(defaultTab);
+              }
+              module.error(error.recursion);
             }
-            module.error(error.recursion);
-          }
-          else {
-            module.debug('No default tabs found for', tabPath, $tabs);
+            else {
+              module.debug('No default tabs found for', tabPath, $tabs);
+            }
+            recursionDepth = 0;
+            return tabPath;
+          },
+          navElement: function(tabPath) {
+            tabPath = tabPath || activeTabPath;
+            return $allModules.filter('[data-' + metadata.tab + '="' + tabPath + '"]');
+          },
+          tabElement: function(tabPath) {
+            var
+              $fullPathTab,
+              $simplePathTab,
+              tabPathArray,
+              lastTab
+            ;
+            tabPath        = tabPath || activeTabPath;
+            tabPathArray   = module.utilities.pathToArray(tabPath);
+            lastTab        = module.utilities.last(tabPathArray);
+            $fullPathTab   = $tabs.filter('[data-' + metadata.tab + '="' + lastTab + '"]');
+            $simplePathTab = $tabs.filter('[data-' + metadata.tab + '="' + tabPath + '"]');
+            return ($fullPathTab.size() > 0)
+              ? $fullPathTab
+              : $simplePathTab
+            ;
+          },
+          tab: function() {
+            return activeTabPath;
           }
-          recursionDepth = 0;
-          return tabPath;
         },
-        navElement: function(tabPath) {
-          tabPath = tabPath || activeTabPath;
-          return $module.filter('[data-' + metadata.tab + '="' + tabPath + '"]');
-        },
-        tabElement: function(tabPath) {
-          var
-            $fullPathTab,
-            $simplePathTab,
-            tabPathArray,
-            lastTab
-          ;
-          tabPath        = tabPath || activeTabPath;
-          tabPathArray   = module.utilities.pathToArray(tabPath);
-          lastTab        = module.utilities.last(tabPathArray);
-          $fullPathTab   = $tabs.filter('[data-' + metadata.tab + '="' + lastTab + '"]');
-          $simplePathTab = $tabs.filter('[data-' + metadata.tab + '="' + tabPath + '"]');
-          return ($fullPathTab.size() > 0)
-            ? $fullPathTab
-            : $simplePathTab
-          ;
-        },
-        tab: function() {
-          return activeTabPath;
-        }
-      },
 
-      utilities: {
-        filterArray: function(keepArray, removeArray) {
-          return $.grep(keepArray, function(keepValue) {
-            return ( $.inArray(keepValue, removeArray) == -1);
-          });
-        },
-        last: function(array) {
-          return $.isArray(array)
-            ? array[ array.length - 1]
-            : false
-          ;
-        },
-        pathToArray: function(pathName) {
-          if(pathName === undefined) {
-            pathName = activeTabPath;
+        utilities: {
+          filterArray: function(keepArray, removeArray) {
+            return $.grep(keepArray, function(keepValue) {
+              return ( $.inArray(keepValue, removeArray) == -1);
+            });
+          },
+          last: function(array) {
+            return $.isArray(array)
+              ? array[ array.length - 1]
+              : false
+            ;
+          },
+          pathToArray: function(pathName) {
+            if(pathName === undefined) {
+              pathName = activeTabPath;
+            }
+            return typeof pathName == 'string'
+              ? pathName.split('/')
+              : [pathName]
+            ;
+          },
+          arrayToPath: function(pathArray) {
+            return $.isArray(pathArray)
+              ? pathArray.join('/')
+              : false
+            ;
           }
-          return typeof pathName == 'string'
-            ? pathName.split('/')
-            : [pathName]
-          ;
         },
-        arrayToPath: function(pathArray) {
-          return $.isArray(pathArray)
-            ? pathArray.join('/')
-            : false
-          ;
-        }
-      },
 
-      setting: function(name, value) {
-        if( $.isPlainObject(name) ) {
-          $.extend(true, settings, name);
-        }
-        else if(value !== undefined) {
-          settings[name] = value;
-        }
-        else {
-          return settings[name];
-        }
-      },
-      internal: function(name, value) {
-        if( $.isPlainObject(name) ) {
-          $.extend(true, module, name);
-        }
-        else if(value !== undefined) {
-          module[name] = value;
-        }
-        else {
-          return module[name];
-        }
-      },
-      debug: function() {
-        if(settings.debug) {
-          if(settings.performance) {
-            module.performance.log(arguments);
+        setting: function(name, value) {
+          module.debug('Changing setting', name, value);
+          if( $.isPlainObject(name) ) {
+            $.extend(true, settings, name);
+          }
+          else if(value !== undefined) {
+            settings[name] = value;
           }
           else {
-            module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
-            module.debug.apply(console, arguments);
+            return settings[name];
           }
-        }
-      },
-      verbose: function() {
-        if(settings.verbose && settings.debug) {
-          if(settings.performance) {
-            module.performance.log(arguments);
+        },
+        internal: function(name, value) {
+          if( $.isPlainObject(name) ) {
+            $.extend(true, module, name);
           }
-          else {
-            module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
-            module.verbose.apply(console, arguments);
+          else if(value !== undefined) {
+            module[name] = value;
           }
-        }
-      },
-      error: function() {
-        module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
-        module.error.apply(console, arguments);
-      },
-      performance: {
-        log: function(message) {
-          var
-            currentTime,
-            executionTime,
-            previousTime
-          ;
-          if(settings.performance) {
-            currentTime   = new Date().getTime();
-            previousTime  = time || currentTime;
-            executionTime = currentTime - previousTime;
-            time          = currentTime;
-            performance.push({
-              'Element'        : element,
-              'Name'           : message[0],
-              'Arguments'      : [].slice.call(message, 1) || '',
-              'Execution Time' : executionTime
-            });
+          else {
+            return module[name];
           }
-          clearTimeout(module.performance.timer);
-          module.performance.timer = setTimeout(module.performance.display, 100);
         },
-        display: function() {
-          var
-            title = settings.name + ':',
-            totalTime = 0
-          ;
-          time = false;
-          clearTimeout(module.performance.timer);
-          $.each(performance, function(index, data) {
-            totalTime += data['Execution Time'];
-          });
-          title += ' ' + totalTime + 'ms';
-          if(moduleSelector) {
-            title += ' \'' + moduleSelector + '\'';
-          }
-          if( (console.group !== undefined || console.table !== undefined) && performance.length > 0) {
-            console.groupCollapsed(title);
-            if(console.table) {
-              console.table(performance);
+        debug: function() {
+          if(settings.debug) {
+            if(settings.performance) {
+              module.performance.log(arguments);
             }
             else {
-              $.each(performance, function(index, data) {
-                console.log(data['Name'] + ': ' + data['Execution Time']+'ms');
-              });
+              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
+              module.debug.apply(console, arguments);
             }
-            console.groupEnd();
           }
-          performance = [];
-        }
-      },
-      invoke: function(query, passedArguments, context) {
-        var
-          object = instance,
-          maxDepth,
-          found,
-          response
-        ;
-        passedArguments = passedArguments || queryArguments;
-        context         = element         || context;
-        if(typeof query == 'string' && object !== undefined) {
-          query    = query.split(/[\. ]/);
-          maxDepth = query.length - 1;
-          $.each(query, function(depth, value) {
-            var camelCaseValue = (depth != maxDepth)
-              ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
-              : query
-            ;
-            if( $.isPlainObject( object[camelCaseValue] ) && (depth != maxDepth) ) {
-              object = object[camelCaseValue];
+        },
+        verbose: function() {
+          if(settings.verbose && settings.debug) {
+            if(settings.performance) {
+              module.performance.log(arguments);
             }
-            else if( object[camelCaseValue] !== undefined ) {
-              found = object[camelCaseValue];
-              return false;
+            else {
+              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
+              module.verbose.apply(console, arguments);
             }
-            else if( $.isPlainObject( object[value] ) && (depth != maxDepth) ) {
-              object = object[value];
+          }
+        },
+        error: function() {
+          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
+          module.error.apply(console, arguments);
+        },
+        performance: {
+          log: function(message) {
+            var
+              currentTime,
+              executionTime,
+              previousTime
+            ;
+            if(settings.performance) {
+              currentTime   = new Date().getTime();
+              previousTime  = time || currentTime;
+              executionTime = currentTime - previousTime;
+              time          = currentTime;
+              performance.push({
+                'Name'           : message[0],
+                'Arguments'      : [].slice.call(message, 1) || '',
+                'Element'        : element,
+                'Execution Time' : executionTime
+              });
             }
-            else if( object[value] !== undefined ) {
-              found = object[value];
-              return false;
+            clearTimeout(module.performance.timer);
+            module.performance.timer = setTimeout(module.performance.display, 100);
+          },
+          display: function() {
+            var
+              title = settings.name + ':',
+              totalTime = 0
+            ;
+            time = false;
+            clearTimeout(module.performance.timer);
+            $.each(performance, function(index, data) {
+              totalTime += data['Execution Time'];
+            });
+            title += ' ' + totalTime + 'ms';
+            if(moduleSelector) {
+              title += ' \'' + moduleSelector + '\'';
             }
-            else {
-              return false;
+            if( (console.group !== undefined || console.table !== undefined) && performance.length > 0) {
+              console.groupCollapsed(title);
+              if(console.table) {
+                console.table(performance);
+              }
+              else {
+                $.each(performance, function(index, data) {
+                  console.log(data['Name'] + ': ' + data['Execution Time']+'ms');
+                });
+              }
+              console.groupEnd();
             }
-          });
-        }
-        if ( $.isFunction( found ) ) {
-          response = found.apply(context, passedArguments);
-        }
-        else if(found !== undefined) {
-          response = found;
-        }
-        if($.isArray(returnedValue)) {
-          returnedValue.push(response);
-        }
-        else if(returnedValue !== undefined) {
-          returnedValue = [returnedValue, response];
+            performance = [];
+          }
+        },
+        invoke: function(query, passedArguments, context) {
+          var
+            object = instance,
+            maxDepth,
+            found,
+            response
+          ;
+          passedArguments = passedArguments || queryArguments;
+          context         = element         || context;
+          if(typeof query == 'string' && object !== undefined) {
+            query    = query.split(/[\. ]/);
+            maxDepth = query.length - 1;
+            $.each(query, function(depth, value) {
+              var camelCaseValue = (depth != maxDepth)
+                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
+                : query
+              ;
+              if( $.isPlainObject( object[camelCaseValue] ) && (depth != maxDepth) ) {
+                object = object[camelCaseValue];
+              }
+              else if( object[camelCaseValue] !== undefined ) {
+                found = object[camelCaseValue];
+                return false;
+              }
+              else if( $.isPlainObject( object[value] ) && (depth != maxDepth) ) {
+                object = object[value];
+              }
+              else if( object[value] !== undefined ) {
+                found = object[value];
+                return false;
+              }
+              else {
+                module.error(error.method, query);
+                return false;
+              }
+            });
+          }
+          if ( $.isFunction( found ) ) {
+            response = found.apply(context, passedArguments);
+          }
+          else if(found !== undefined) {
+            response = found;
+          }
+          if($.isArray(returnedValue)) {
+            returnedValue.push(response);
+          }
+          else if(returnedValue !== undefined) {
+            returnedValue = [returnedValue, response];
+          }
+          else if(response !== undefined) {
+            returnedValue = response;
+          }
+          return found;
         }
-        else if(response !== undefined) {
-          returnedValue = response;
+      };
+      if(methodInvoked) {
+        if(instance === undefined) {
+          module.initialize();
         }
-        return found;
+        module.invoke(query);
       }
-    };
-
-    if(methodInvoked) {
-      if(instance === undefined) {
+      else {
+        if(instance !== undefined) {
+          module.destroy();
+        }
         module.initialize();
       }
-      module.invoke(query);
-    }
-    else {
-      if(instance !== undefined) {
-        module.destroy();
-      }
-      module.initialize();
-    }
-
-    return (returnedValue !== undefined)
-      ? returnedValue
-      : this
-    ;
-
-  };
-
-  // shortcut for tabbed content with no defined navigation
-  $.tab = function(settings) {
-    $(window).tab(settings);
-  };
-
-  $.fn.tab.settings = {
-
-    name        : 'Tab',
-    debug       : false,
-    verbose     : true,
-    performance : true,
-    namespace   : 'tab',
-
-    // only called first time a tab's content is loaded (when remote source)
-    onTabInit   : function(tabPath, parameterArray, historyEvent) {},
-    // called on every load
-    onTabLoad   : function(tabPath, parameterArray, historyEvent) {},
-
-    templates   : {
-      determineTitle: function(tabArray) {}
-    },
-
-    // uses pjax style endpoints fetching content from same url with remote-content headers
-    auto            : false,
-    history         : true,
-    historyType     : 'hash',
-    path            : false,
-
-    context         : 'body',
-
-    // max depth a tab can be nested
-    maxDepth        : 25,
-    // dont load content on first load
-    ignoreFirstLoad : false,
-    // load tab content new every tab click
-    alwaysRefresh   : false,
-    // cache the content requests to pull locally
-    cache           : true,
-    // settings for api call
-    apiSettings     : false,
-
-    error: {
-      api        : 'You attempted to load content without API module',
-      method     : 'The method you called is not defined',
-      missingTab : 'Tab cannot be found',
-      noContent  : 'The tab you specified is missing a content url.',
-      path       : 'History enabled, but no path was specified',
-      recursion  : 'Max recursive depth reached',
-      state      : 'The state library has not been initialized'
-    },
-
-    metadata : {
-      tab    : 'tab',
-      loaded : 'loaded',
-      promise: 'promise'
-    },
-
-    className   : {
-      loading : 'loading',
-      active  : 'active'
-    },
-
-    selector    : {
-      tabs : '.ui.tab'
-    }
-
-  };
-
-})( jQuery, window , document );
+    })
+  ;
+  if(module && !methodInvoked) {
+    module.initializeHistory();
+  }
+  return (returnedValue !== undefined)
+    ? returnedValue
+    : this
+  ;
+
+};
+
+// shortcut for tabbed content with no defined navigation
+$.tab = function() {
+  $(window).tab.apply(this, arguments);
+};
+
+$.fn.tab.settings = {
+
+  name            : 'Tab',
+  namespace       : 'tab',
+
+  debug           : false,
+  verbose         : true,
+  performance     : true,
+
+  auto            : false,  // uses pjax style endpoints fetching content from same url with remote-content headers
+  history         : false,  // use browser history
+  historyType     : 'hash', // #/ or html5 state
+  path            : false,  // base path of url
+
+  context         : false,  // specify a context that tabs must appear inside
+  childrenOnly    : false,  // use only tabs that are children of context
+  maxDepth        : 25,     // max depth a tab can be nested
+
+  alwaysRefresh   : false,  // load tab content new every tab click
+  cache           : true,   // cache the content requests to pull locally
+  ignoreFirstLoad : false,  // don't load remote content on first load
+  apiSettings     : false,  // settings for api call
+
+  onTabInit    : function(tabPath, parameterArray, historyEvent) {}, // called first time loaded
+  onTabLoad    : function(tabPath, parameterArray, historyEvent) {}, // called on every load
+
+  templates    : {
+    determineTitle: function(tabArray) {} // returns page title for path
+  },
+
+  error: {
+    api        : 'You attempted to load content without API module',
+    method     : 'The method you called is not defined',
+    missingTab : 'Activated tab cannot be found for this context.',
+    noContent  : 'The tab you specified is missing a content url.',
+    path       : 'History enabled, but no path was specified',
+    recursion  : 'Max recursive depth reached',
+    state      : 'History requires Asual\'s Address library <https://github.com/asual/jquery-address>'
+  },
+
+  metadata : {
+    tab    : 'tab',
+    loaded : 'loaded',
+    promise: 'promise'
+  },
+
+  className   : {
+    loading : 'loading',
+    active  : 'active'
+  },
+
+  selector    : {
+    tabs : '.ui.tab',
+    ui   : '.ui'
+  }
+
+};
+
+})( jQuery, window , document );