prettydocs_rails 1.1.16

data/vendor/assets/javascripts/jquery-match-height/CHANGELOG.md

@@ -0,0 +1,24 @@
+# jquery.matchHeight.js Changelog
+
+[brm.io/jquery-match-height](http://brm.io/jquery-match-height/)
+
+----------
+
+## 0.5.2
+
+- improved demo
+- added matchHeight('remove')
+- added update throttling
+- removed forced `display:block` after application
+
+## 0.5.1
+
+- fixed IE8 NaN bug when parsing 'auto' properties
+- fixed IE8 window resize event loop bug
+- fixed compatibility with older jQuery versions
+- added bower package file
+- added jquery package file
+
+## 0.5.0 - 2014-03-02
+
+- initial release

data/vendor/assets/javascripts/jquery-match-height/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Liam Brummitt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/vendor/assets/javascripts/jquery-match-height/README.md

@@ -0,0 +1,170 @@
+# jquery.matchHeight.js #
+
+> *matchHeight* makes the height of all selected elements exactly equal.<br>
+It handles many edge cases that cause similar plugins to fail.
+
+[brm.io/jquery-match-height](http://brm.io/jquery-match-height/)
+
+### Demo
+
+See the [jquery.matchHeight.js demo](http://brm.io/jquery-match-height-demo).
+
+[![jquery.matchHeight.js screenshot](http://brm.io/img/content/jquery-match-height/jquery-match-height.png)](http://brm.io/jquery-match-height-demo)
+
+### Features
+
+- match the heights of elements anywhere on the page
+- row aware, handles floating elements
+- responsive, automatically updates on window resize (can be throttled for performance)
+- handles mixed `padding`, `margin`, `border` values (even if every element has them different)
+- handles images and other media (updates automatically after loading)
+- handles hidden or none-visible elements (e.g. those inside tab controls)
+- accounts for `box-sizing`
+- data attributes API
+- can be removed when needed
+- maintain scroll position correctly
+- callback events
+- tested in IE8+, Chrome, Firefox, Chrome Android
+
+### Status
+
+Current version is `v0.5.2`. I've fully tested it and it works well, but if you use it make sure you test fully too. 
+Please report any [issues](https://github.com/liabru/jquery-match-height/issues) you find.
+
+### Install
+
+[jQuery](http://jquery.com/download/) is required, so include it first.
+<br>Download [jquery.matchHeight.js](https://github.com/liabru/jquery-match-height/blob/master/jquery.matchHeight.js) and include the script in your HTML file:
+
+	<script src="jquery.matchHeight.js" type="text/javascript"></script>
+
+#### Or install using [Bower](http://bower.io/)
+
+	bower install matchHeight
+
+### Usage
+
+	$(elements).matchHeight(byRow);
+
+Where `byRow` is a boolean that enables or disables row detection, default is `true`.<br>
+You should apply this on the [DOM ready](http://api.jquery.com/ready/) event.
+
+See the included [test.html](https://github.com/liabru/jquery-match-height/blob/master/test.html) for a working example.
+
+### Examples
+
+	$(function() {
+		$('.item').matchHeight();
+	});
+
+Will set all elements with the class `item` to the height of the tallest.<br>
+If the items are on multiple rows, the items of each row will be set to the tallest of that row.
+
+	<div data-mh="my-group">My text</div>
+	<div data-mh="my-group">Some other text</div>
+	<div data-mh="my-other-group">Even more text</div>
+	<div data-mh="my-other-group">The last bit of text</div>
+
+Will set both elements in `my-group` to the same height, then both elements in `my-other-group` to be the same height respectively.
+
+See the included [test.html](https://github.com/liabru/jquery-match-height/blob/master/test.html) for a working example.
+
+### Advanced Usage
+
+There are a few internal properties and functions you should know about:
+
+#### Data API
+
+Use the data attribute `data-match-height="group-name"` (or `data-mh` shorthand) where `group-name` is an arbitrary string to denote which elements should be considered as a group.
+
+All elements with the same group name will be set to the same height when the page is loaded, regardless of their position in the DOM, without any extra code required. 
+
+Note that `byRow` will be enabled when using the data API, if you don't want this then use the alternative method above.
+
+#### Callback events
+
+Since matchHeight automatically handles updating the layout after certain window events, you can supply functions as global callbacks if you need to be notified:
+
+    $.fn.matchHeight._beforeUpdate = function(event, groups) {
+        // do something before any updates are applied
+    }
+
+    $.fn.matchHeight._afterUpdate = function(event, groups) {
+        // do something after all updates are applied
+    }
+
+Where `event` a jQuery event object (e.g. `load`, `resize`, `orientationchange`) and `groups` is a reference to `$.fn.matchHeight._groups` (see below).
+
+#### Removing
+
+It is possible to remove any matchHeight bindings for a given set of elements like so
+
+	$('.item').matchHeight('remove');
+
+#### Manually trigger an update
+
+	$.fn.matchHeight._update()
+
+If you need to manually trigger an update of all currently set equal heights groups, for example if you've modified some content.
+
+#### Manually apply match height
+
+	$.fn.matchHeight._apply(elements, byRow)
+
+Use the apply function directly if you wish to avoid the automatic update functionality.
+
+#### Throttling resize updates
+
+	$.fn.matchHeight._throttle = 80;
+
+By default, the `_update` method is throttled to execute at a maximum rate of once every `80ms`.
+Decreasing the above `_throttle` property will update your layout quicker, appearing smoother during resize, at the expense of performance.
+If you experience lagging or freezing during resize, you should increase the `_throttle` property.
+
+#### Maintain scroll position
+
+	$.fn.matchHeight._maintainScroll = true;
+
+Under certain conditions where the size of the page is dynamically changing, such as during resize or when adding new elements, browser bugs cause the page scroll position to change unexpectedly.
+
+If you are observing this behaviour, use the above line to automatically attempt to force scroll position to be maintained (approximately). This is a global setting and by default it is `false`.
+
+#### Accessing groups directly
+
+	$.fn.matchHeight._groups
+
+The array that contains all element groups that have had `matchHeight` applied. Used for automatically updating on resize events. Search and modify this array if you need to remove any groups or elements, for example if you're deleting elements.
+
+### Known limitations
+
+#### CSS transitions and animations are not supported
+
+You should ensure that there are no transitions or other animations that will delay the height changes of the elements you are matching, including any `transition: all` rules. Otherwise the plugin will produce unexpected results, as animations can't be accounted for.
+
+#### Delayed webfonts may cause incorrect height
+
+Some browsers [do not wait](http://www.stevesouders.com/blog/2009/10/13/font-face-and-performance/) for webfonts to load before firing the window load event, so if the font loads too slowly the plugin may produce unexpected results.
+
+If this is a problem, you should call `_update` once your font has loaded by using something like the [webfontloader](https://github.com/typekit/webfontloader) script.
+
+#### Content changes require a manual update
+
+If you change the content inside an element that has had `matchHeight` applied, then you must manually call `$.fn.matchHeight._update()` afterwards. This will update of all currently set equal heights groups.
+
+### Changelog
+
+To see what's new or changed in the latest version, see the [changelog](https://github.com/liabru/jquery-match-height/blob/master/CHANGELOG.md)
+
+### License
+
+jquery.matchHeight.js is licensed under [The MIT License (MIT)](http://opensource.org/licenses/MIT)
+<br/>Copyright (c) 2014 Liam Brummitt
+
+This license is also supplied with the release and source code.
+<br/>As stated in the license, absolutely no warranty is provided.
+
+##### Why not use CSS?
+
+Making robust, responsive equal height columns for _arbitrary content_ is [difficult or impossible](http://filamentgroup.com/lab/setting_equal_heights_with_jquery/) to do with CSS alone (at least without hacks or trickery, in a backwards compatible way).
+
+Note you should probably ensure your layout is still usable if JavaScript is disabled.

data/vendor/assets/javascripts/jquery-match-height/bower.json

@@ -0,0 +1,26 @@
+{
+    "name": "matchHeight",
+    "version": "0.5.2",
+    "homepage": "https://github.com/liabru/jquery-match-height",
+    "authors": [
+        "Liam Brummitt <liam@brm.io> (http://brm.io/)"
+    ],
+    "description": "a more robust, responsive equal heights plugin for jQuery",
+    "main": "jquery.matchHeight-min.js",
+    "keywords": [
+        "matchHeight",
+        "equal",
+        "match",
+        "height",
+        "equalize",
+        "columns"
+    ],
+    "license": "MIT",
+    "ignore": [
+        "**/.*",
+        "node_modules",
+        "bower_components",
+        "test",
+        "tests"
+    ]
+}

data/vendor/assets/javascripts/jquery-match-height/jquery.matchHeight-min.js

@@ -0,0 +1,10 @@
+/**
+* jquery.matchHeight-min.js v0.5.2
+* http://brm.io/jquery-match-height/
+* License: MIT
+*/
+(function(d){var g=-1,e=-1,n=function(a){var b=null,c=[];d(a).each(function(){var a=d(this),k=a.offset().top-h(a.css("margin-top")),l=0<c.length?c[c.length-1]:null;null===l?c.push(a):1>=Math.floor(Math.abs(b-k))?c[c.length-1]=l.add(a):c.push(a);b=k});return c},h=function(a){return parseFloat(a)||0},b=d.fn.matchHeight=function(a){if("remove"===a){var f=this;this.css("height","");d.each(b._groups,function(a,b){b.elements=b.elements.not(f)});return this}if(1>=this.length)return this;a="undefined"!==
+typeof a?a:!0;b._groups.push({elements:this,byRow:a});b._apply(this,a);return this};b._groups=[];b._throttle=80;b._maintainScroll=!1;b._beforeUpdate=null;b._afterUpdate=null;b._apply=function(a,f){var c=d(a),e=[c],k=d(window).scrollTop(),l=d("html").outerHeight(!0),g=c.parents().filter(":hidden");g.css("display","block");f&&(c.each(function(){var a=d(this),b="inline-block"===a.css("display")?"inline-block":"block";a.data("style-cache",a.attr("style"));a.css({display:b,"padding-top":"0","padding-bottom":"0",
+"margin-top":"0","margin-bottom":"0","border-top-width":"0","border-bottom-width":"0",height:"100px"})}),e=n(c),c.each(function(){var a=d(this);a.attr("style",a.data("style-cache")||"").css("height","")}));d.each(e,function(a,b){var c=d(b),e=0;f&&1>=c.length||(c.each(function(){var a=d(this),b="inline-block"===a.css("display")?"inline-block":"block";a.css({display:b,height:""});a.outerHeight(!1)>e&&(e=a.outerHeight(!1));a.css("display","")}),c.each(function(){var a=d(this),b=0;"border-box"!==a.css("box-sizing")&&
+(b+=h(a.css("border-top-width"))+h(a.css("border-bottom-width")),b+=h(a.css("padding-top"))+h(a.css("padding-bottom")));a.css("height",e-b)}))});g.css("display","");b._maintainScroll&&d(window).scrollTop(k/l*d("html").outerHeight(!0));return this};b._applyDataApi=function(){var a={};d("[data-match-height], [data-mh]").each(function(){var b=d(this),c=b.attr("data-match-height")||b.attr("data-mh");a[c]=c in a?a[c].add(b):b});d.each(a,function(){this.matchHeight(!0)})};var m=function(a){b._beforeUpdate&&
+b._beforeUpdate(a,b._groups);d.each(b._groups,function(){b._apply(this.elements,this.byRow)});b._afterUpdate&&b._afterUpdate(a,b._groups)};b._update=function(a,f){if(f&&"resize"===f.type){var c=d(window).width();if(c===g)return;g=c}a?-1===e&&(e=setTimeout(function(){m(f);e=-1},b._throttle)):m(f)};d(b._applyDataApi);d(window).bind("load",function(a){b._update(!1,a)});d(window).bind("resize orientationchange",function(a){b._update(!0,a)})})(jQuery);

data/vendor/assets/javascripts/jquery-match-height/jquery.matchHeight.js

@@ -0,0 +1,298 @@
+/**
+* jquery.matchHeight.js v0.5.2
+* http://brm.io/jquery-match-height/
+* License: MIT
+*/
+
+;(function($) {
+    /*
+    *  internal
+    */
+
+    var _previousResizeWidth = -1,
+        _updateTimeout = -1;
+
+    /*
+    *  _rows
+    *  utility function returns array of jQuery selections representing each row
+    *  (as displayed after float wrapping applied by browser)
+    */
+
+    var _rows = function(elements) {
+        var tolerance = 1,
+            $elements = $(elements),
+            lastTop = null,
+            rows = [];
+
+        // group elements by their top position
+        $elements.each(function(){
+            var $that = $(this),
+                top = $that.offset().top - _parse($that.css('margin-top')),
+                lastRow = rows.length > 0 ? rows[rows.length - 1] : null;
+
+            if (lastRow === null) {
+                // first item on the row, so just push it
+                rows.push($that);
+            } else {
+                // if the row top is the same, add to the row group
+                if (Math.floor(Math.abs(lastTop - top)) <= tolerance) {
+                    rows[rows.length - 1] = lastRow.add($that);
+                } else {
+                    // otherwise start a new row group
+                    rows.push($that);
+                }
+            }
+
+            // keep track of the last row top
+            lastTop = top;
+        });
+
+        return rows;
+    };
+
+    /*
+    *  _parse
+    *  value parse utility function
+    */
+
+    var _parse = function(value) {
+        // parse value and convert NaN to 0
+        return parseFloat(value) || 0;
+    };
+
+    /*
+    *  matchHeight
+    *  plugin definition
+    */
+
+    var matchHeight = $.fn.matchHeight = function(byRow) {
+
+        // handle matchHeight('remove')
+        if (byRow === 'remove') {
+            var that = this;
+
+            // remove fixed height from all selected elements
+            this.css('height', '');
+
+            // remove selected elements from all groups
+            $.each(matchHeight._groups, function(key, group) {
+                group.elements = group.elements.not(that);
+            });
+
+            // TODO: cleanup empty groups
+
+            return this;
+        }
+
+        if (this.length <= 1)
+            return this;
+
+        // byRow default to true
+        byRow = (typeof byRow !== 'undefined') ? byRow : true;
+
+        // keep track of this group so we can re-apply later on load and resize events
+        matchHeight._groups.push({
+            elements: this,
+            byRow: byRow
+        });
+
+        // match each element's height to the tallest element in the selection
+        matchHeight._apply(this, byRow);
+
+        return this;
+    };
+
+    /*
+    *  plugin global options
+    */
+
+    matchHeight._groups = [];
+    matchHeight._throttle = 80;
+    matchHeight._maintainScroll = false;
+    matchHeight._beforeUpdate = null;
+    matchHeight._afterUpdate = null;
+
+    /*
+    *  matchHeight._apply
+    *  apply matchHeight to given elements
+    */
+
+    matchHeight._apply = function(elements, byRow) {
+        var $elements = $(elements),
+            rows = [$elements];
+
+        // take note of scroll position
+        var scrollTop = $(window).scrollTop(),
+            htmlHeight = $('html').outerHeight(true);
+
+        // temporarily must force hidden parents visible
+        var $hiddenParents = $elements.parents().filter(':hidden');
+        $hiddenParents.css('display', 'block');
+
+        // get rows if using byRow, otherwise assume one row
+        if (byRow) {
+
+            // must first force an arbitrary equal height so floating elements break evenly
+            $elements.each(function() {
+                var $that = $(this),
+                    display = $that.css('display') === 'inline-block' ? 'inline-block' : 'block';
+
+                // cache the original inline style
+                $that.data('style-cache', $that.attr('style'));
+
+                $that.css({
+                    'display': display,
+                    'padding-top': '0',
+                    'padding-bottom': '0',
+                    'margin-top': '0',
+                    'margin-bottom': '0',
+                    'border-top-width': '0',
+                    'border-bottom-width': '0',
+                    'height': '100px'
+                });
+            });
+
+            // get the array of rows (based on element top position)
+            rows = _rows($elements);
+
+            // revert original inline styles
+            $elements.each(function() {
+                var $that = $(this);
+
+                $that.attr('style', $that.data('style-cache') || '')
+                     .css('height', '');
+            });
+        }
+
+        $.each(rows, function(key, row) {
+            var $row = $(row),
+                maxHeight = 0;
+
+            // skip apply to rows with only one item
+            if (byRow && $row.length <= 1)
+                return;
+
+            // iterate the row and find the max height
+            $row.each(function(){
+                var $that = $(this),
+                    display = $that.css('display') === 'inline-block' ? 'inline-block' : 'block';
+
+                // ensure we get the correct actual height (and not a previously set height value)
+                $that.css({ 'display': display, 'height': '' });
+
+                // find the max height (including padding, but not margin)
+                if ($that.outerHeight(false) > maxHeight)
+                    maxHeight = $that.outerHeight(false);
+
+                // revert display block
+                $that.css('display', '');
+            });
+
+            // iterate the row and apply the height to all elements
+            $row.each(function(){
+                var $that = $(this),
+                    verticalPadding = 0;
+
+                // handle padding and border correctly (required when not using border-box)
+                if ($that.css('box-sizing') !== 'border-box') {
+                    verticalPadding += _parse($that.css('border-top-width')) + _parse($that.css('border-bottom-width'));
+                    verticalPadding += _parse($that.css('padding-top')) + _parse($that.css('padding-bottom'));
+                }
+
+                // set the height (accounting for padding and border)
+                $that.css('height', maxHeight - verticalPadding);
+            });
+        });
+
+        // revert hidden parents
+        $hiddenParents.css('display', '');
+
+        // restore scroll position if enabled
+        if (matchHeight._maintainScroll)
+            $(window).scrollTop((scrollTop / htmlHeight) * $('html').outerHeight(true));
+
+        return this;
+    };
+
+    /*
+    *  matchHeight._applyDataApi
+    *  applies matchHeight to all elements with a data-match-height attribute
+    */
+
+    matchHeight._applyDataApi = function() {
+        var groups = {};
+
+        // generate groups by their groupId set by elements using data-match-height
+        $('[data-match-height], [data-mh]').each(function() {
+            var $this = $(this),
+                groupId = $this.attr('data-match-height') || $this.attr('data-mh');
+            if (groupId in groups) {
+                groups[groupId] = groups[groupId].add($this);
+            } else {
+                groups[groupId] = $this;
+            }
+        });
+
+        // apply matchHeight to each group
+        $.each(groups, function() {
+            this.matchHeight(true);
+        });
+    };
+
+    /*
+    *  matchHeight._update
+    *  updates matchHeight on all current groups with their correct options
+    */
+
+    var _update = function(event) {
+        if (matchHeight._beforeUpdate)
+            matchHeight._beforeUpdate(event, matchHeight._groups);
+
+        $.each(matchHeight._groups, function() {
+            matchHeight._apply(this.elements, this.byRow);
+        });
+
+        if (matchHeight._afterUpdate)
+            matchHeight._afterUpdate(event, matchHeight._groups);
+    };
+
+    matchHeight._update = function(throttle, event) {
+        // prevent update if fired from a resize event
+        // where the viewport width hasn't actually changed
+        // fixes an event looping bug in IE8
+        if (event && event.type === 'resize') {
+            var windowWidth = $(window).width();
+            if (windowWidth === _previousResizeWidth)
+                return;
+            _previousResizeWidth = windowWidth;
+        }
+
+        // throttle updates
+        if (!throttle) {
+            _update(event);
+        } else if (_updateTimeout === -1) {
+            _updateTimeout = setTimeout(function() {
+                _update(event);
+                _updateTimeout = -1;
+            }, matchHeight._throttle);
+        }
+    };
+
+    /*
+    *  bind events
+    */
+
+    // apply on DOM ready event
+    $(matchHeight._applyDataApi);
+
+    // update heights on load and resize events
+    $(window).bind('load', function(event) {
+        matchHeight._update(false, event);
+    });
+
+    // throttled update heights on resize events
+    $(window).bind('resize orientationchange', function(event) {
+        matchHeight._update(true, event);
+    });
+
+})(jQuery);