jquery-mjs-nestedSortable-rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f53549929a16d69fa3e5841844440fb089dc6d4c
+  data.tar.gz: f5219f306b029a13a499fd9717a664c1ff4b43eb
+SHA512:
+  metadata.gz: 739c6ebb755770dd82acaffa3ba8ffb32a2f84fb651b58d2d4135c8ecff109b70e5331b26c771d66cbe0421a68e4ed0d2f161ef60d29d4a5c5953f5d4c768fcb
+  data.tar.gz: db31fb694e824561abe1048debc4904e5684e5f1bc5fc07d984a6130b29495d776b257bde4fcde6ca7c80e7135091651bb5a151308ef1d5c2a9fab1b3567f8e3

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Michael Sprauer, Manuele J Sarfatti
+
+MIT License
+
+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/README.md

@@ -0,0 +1,147 @@
+# Jquery::Mjs::NestedSortable::Rails
+
+Rails version of [mjs.nestedSortable](https://github.com/mjsarfatti/nestedSortable)
+
+*nestedSortable* is a jQuery plugin that extends jQuery Sortable UI functionalities to nested lists.
+*Note:* **Version 2.0** *is published in branch '2.0alpha' and is ready for testing! At the moment it has only been tested in Firefox and Chrome, if you work with IE feel free to give it a shot and let me know if something goes wrong.*
+
+## Features
+
+- Designed to work seamlessly with the [nested](http://articles.sitepoint.com/article/hierarchical-data-database "A Sitepoint tutorial on PHP, MYSQL and nested sets") [set](http://en.wikipedia.org/wiki/Nested_set_model "Wikipedia article on nested sets") model (have a look at the `toArray` method)
+- Items can be sorted in their own list, moved across the tree, or nested under other items.
+- Sublists are created and deleted on the fly
+- All jQuery Sortable options, events and methods are available
+- It is possible to define elements that will not accept a new nested item/list and a maximum depth for nested items
+- The root level can be protected
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'jquery-mjs-nestedSortable-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jquery-mjs-nestedSortable-rails
+
+## Usage
+
+```
+<ol class="sortable">
+	<li><div>Some content</div></li>
+	<li>
+		<div>Some content</div>
+		<ol>
+			<li><div>Some sub-item content</div></li>
+			<li><div>Some sub-item content</div></li>
+		</ol>
+	</li>
+	<li><div>Some content</div></li>
+</ol>
+```
+
+```
+	$(document).ready(function(){
+
+		$('.sortable').nestedSortable({
+			handle: 'div',
+			items: 'li',
+			toleranceElement: '> div'
+		});
+
+	});
+```
+
+Please note: every `<li>` must have either one or two direct children, the first one being a container element (such as `<div>` in the above example), and the (optional) second one being the nested list. The container element has to be set as the 'toleranceElement' in the options, and this, or one of its children, as the 'handle'.
+
+Also, the default list type is `<ol>`.
+
+## Custom Options
+
+<dl>
+	<dt>tabSize</dt>
+	<dd>How far right or left (in pixels) the item has to travel in order to be nested or to be sent outside its current list. Default: <b>20</b></dd>
+	<dt>disableNesting</dt>
+	<dd>The class name of the items that will not accept nested lists. Default: <b>ui-nestedSortable-no-nesting</b></dd>
+	<dt>errorClass</dt>
+	<dd>The class given to the placeholder in case of error. Default: <b>ui-nestedSortable-error</b></dd>
+	<dt>listType</dt>
+	<dd>The list type used (ordered or unordered). Default: <b>ol</b></dd>
+	<dt>maxLevels</dt>
+	<dd>The maximum depth of nested items the list can accept. If set to '0' the levels are unlimited. Default: <b>0</b></dd>
+	<dt>protectRoot</dt>
+	<dd>Wether to protect the root level (i.e. root items can be sorted but not nested, sub-items cannot become root items). Default: <b>false</b></dd>
+	<dt>rootID</dt>
+	<dd>The id given to the root element (set this to whatever suits your data structure). Default: <b>null</b></dd>
+	<dt>rtl</dt>
+	<dd>Set this to true if you have a right-to-left page. Default: <b>false</b></dd>
+	<dt>isAllowed (function)</dt>
+	<dd>You can specify a custom function to verify if a drop location is allowed. Default: <b>function(item, parent) { return true; }</b></dd>
+</dl>
+
+## Custom Methods
+
+<dl>
+	<dt>serialize</dt>
+	<dd>Serializes the nested list into a string like <b>setName[item1Id]=parentId&setName[item2Id]=parentId</b>, reading from each item's id formatted as 'setName_itemId' (where itemId is a number).
+	It accepts the same options as the original Sortable method (<b>key</b>, <b>attribute</b> and <b>expression</b>).</dd>
+	<dt>toArray</dt>
+	<dd>Builds an array where each element is in the form:
+<pre>setName[n] =>
+{
+	'item_id': itemId,
+	'parent_id': parentId,
+	'depth': depth,
+	'left': left,
+	'right': right,
+}
+</pre>
+	It accepts the same options as the original Sortable method (<b>attribute</b> and <b>expression</b>) plus the custom <b>startDepthCount</b>, that sets the starting depth number (default is <b>0</b>).</dd>
+	<dt>toHierarchy</dt>
+	<dd>Builds a hierarchical object in the form:
+<pre>'0' ...
+	'id' => itemId
+'1' ...
+	'id' => itemId
+	'children' ...
+		'0' ...
+			'id' => itemId
+		'1' ...
+			'id' => itemId
+'2' ...
+	'id' => itemId
+</pre>
+	Similarly to <code>toArray</code>, it accepts <b>attribute</b> and <b>expression</b> options.</dd>
+</dl>
+
+## Known Bugs
+
+*nestedSortable* doesn't work properly with connected draggables, because of the way Draggable simulates Sortable `mouseStart` and `mouseStop` events. This bug might or might not be fixed some time in the future (it's not specific to this plugin).
+
+## Requirements
+
+jQuery 1.4+
+jQuery UI Sortable 1.8+
+
+## Browser Compatibility
+
+Tested with: IE 6/7/8, Firefox 3.6/4, Chrome, Safari 3
+
+## License
+
+This work is licensed under the MIT License.
+
+This work is *pizzaware*. If it saved your life, or you just feel good at heart, please consider offering me a pizza. This can be done in two ways: (1) follow [this link](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=RSJEW3N9PRMYY&lc=IT&item_name=Manuele%20Sarfatti&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted) to donate through paypal; (2) send me cash via traditional mail to my home address in Italy. Is the second method legal? It is in Italy if you use Posta assicurata. You should check with your local laws if you live elsewhere.
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/jquery-mjs-nestedSortable-rails/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+

data/lib/jquery/mjs/nestedSortable/rails.rb

@@ -0,0 +1,12 @@
+require "jquery/mjs/nestedSortable/rails/version"
+
+module Jquery
+  module Mjs
+    module NestedSortable
+      module Rails
+        class Engine < ::Rails::Engine
+        end
+      end
+    end
+  end
+end

data/lib/jquery/mjs/nestedSortable/rails/version.rb

@@ -0,0 +1,9 @@
+module Jquery
+  module Mjs
+    module NestedSortable
+      module Rails
+        VERSION = "0.0.1"
+      end
+    end
+  end
+end

data/vendor/assets/javascripts/jquery.mjs.netsedSortable.js

@@ -0,0 +1,432 @@
+/*
+ * jQuery UI Nested Sortable
+ * v 1.3.5 / 21 jun 2012
+ * http://mjsarfatti.com/code/nestedSortable
+ *
+ * Depends on:
+ *	 jquery.ui.sortable.js 1.8+
+ *
+ * Copyright (c) 2010-2012 Manuele J Sarfatti
+ * Licensed under the MIT License
+ * http://www.opensource.org/licenses/mit-license.php
+ */
+
+(function ($) {
+
+    $.widget("mjs.nestedSortable", $.extend({}, $.ui.sortable.prototype, {
+
+        options: {
+            tabSize: 20,
+            disableNesting: 'mjs-nestedSortable-no-nesting',
+            errorClass: 'mjs-nestedSortable-error',
+            doNotClear: false,
+            listType: 'ol',
+            maxLevels: 0,
+            protectRoot: false,
+            rootID: null,
+            rtl: false,
+            isAllowed: function (item, parent) {
+                return true;
+            }
+        },
+
+        _create: function () {
+            this.element.data('sortable', this.element.data('nestedSortable'));
+
+            if (!this.element.is(this.options.listType))
+                throw new Error('nestedSortable: Please check the listType option is set to your actual list type');
+
+            return $.ui.sortable.prototype._create.apply(this, arguments);
+        },
+
+        destroy: function () {
+            this.element
+                .removeData("nestedSortable")
+                .unbind(".nestedSortable");
+            return $.ui.sortable.prototype.destroy.apply(this, arguments);
+        },
+
+        _mouseDrag: function (event) {
+
+            //Compute the helpers position
+            this.position = this._generatePosition(event);
+            this.positionAbs = this._convertPositionTo("absolute");
+
+            if (!this.lastPositionAbs) {
+                this.lastPositionAbs = this.positionAbs;
+            }
+
+            var o = this.options;
+
+            //Do scrolling
+            if (this.options.scroll) {
+                var scrolled = false;
+                if (this.scrollParent[0] != document && this.scrollParent[0].tagName != 'HTML') {
+
+                    if ((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity)
+                        this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
+                    else if (event.pageY - this.overflowOffset.top < o.scrollSensitivity)
+                        this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
+
+                    if ((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity)
+                        this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
+                    else if (event.pageX - this.overflowOffset.left < o.scrollSensitivity)
+                        this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
+
+                } else {
+
+                    if (event.pageY - $(document).scrollTop() < o.scrollSensitivity)
+                        scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
+                    else if ($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity)
+                        scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
+
+                    if (event.pageX - $(document).scrollLeft() < o.scrollSensitivity)
+                        scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
+                    else if ($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
+                        scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
+
+                }
+
+                if (scrolled !== false && $.ui.ddmanager && !o.dropBehaviour)
+                    $.ui.ddmanager.prepareOffsets(this, event);
+            }
+
+            //Regenerate the absolute position used for position checks
+            this.positionAbs = this._convertPositionTo("absolute");
+
+            // Find the top offset before rearrangement,
+            var previousTopOffset = this.placeholder.offset().top;
+
+            //Set the helper position
+            if (!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left + 'px';
+            if (!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top + 'px';
+
+            //Rearrange
+            for (var i = this.items.length - 1; i >= 0; i--) {
+
+                //Cache variables and intersection, continue if no intersection
+                var item = this.items[i], itemElement = item.item[0], intersection = this._intersectsWithPointer(item);
+                if (!intersection) continue;
+
+                if (itemElement != this.currentItem[0] //cannot intersect with itself
+                    && this.placeholder[intersection == 1 ? "next" : "prev"]()[0] != itemElement //no useless actions that have been done before
+                    && !$.contains(this.placeholder[0], itemElement) //no action if the item moved is the parent of the item checked
+                    && (this.options.type == 'semi-dynamic' ? !$.contains(this.element[0], itemElement) : true)
+                //&& itemElement.parentNode == this.placeholder[0].parentNode // only rearrange items within the same container
+                    ) {
+
+                    $(itemElement).mouseenter();
+
+                    this.direction = intersection == 1 ? "down" : "up";
+
+                    if (this.options.tolerance == "pointer" || this._intersectsWithSides(item)) {
+                        $(itemElement).mouseleave();
+                        this._rearrange(event, item);
+                    } else {
+                        break;
+                    }
+
+                    // Clear emtpy ul's/ol's
+                    this._clearEmpty(itemElement);
+
+                    this._trigger("change", event, this._uiHash());
+                    break;
+                }
+            }
+
+            var parentItem = (this.placeholder[0].parentNode.parentNode &&
+                    $(this.placeholder[0].parentNode.parentNode).closest('.ui-sortable').length)
+                    ? $(this.placeholder[0].parentNode.parentNode)
+                    : null,
+                level = this._getLevel(this.placeholder),
+                childLevels = this._getChildLevels(this.helper);
+
+            // To find the previous sibling in the list, keep backtracking until we hit a valid list item.
+            var previousItem = this.placeholder[0].previousSibling ? $(this.placeholder[0].previousSibling) : null;
+            if (previousItem != null) {
+                while (previousItem[0].nodeName.toLowerCase() != 'li' || previousItem[0] == this.currentItem[0] || previousItem[0] == this.helper[0]) {
+                    if (previousItem[0].previousSibling) {
+                        previousItem = $(previousItem[0].previousSibling);
+                    } else {
+                        previousItem = null;
+                        break;
+                    }
+                }
+            }
+
+            // To find the next sibling in the list, keep stepping forward until we hit a valid list item.
+            var nextItem = this.placeholder[0].nextSibling ? $(this.placeholder[0].nextSibling) : null;
+            if (nextItem != null) {
+                while (nextItem[0].nodeName.toLowerCase() != 'li' || nextItem[0] == this.currentItem[0] || nextItem[0] == this.helper[0]) {
+                    if (nextItem[0].nextSibling) {
+                        nextItem = $(nextItem[0].nextSibling);
+                    } else {
+                        nextItem = null;
+                        break;
+                    }
+                }
+            }
+
+            var newList = document.createElement(o.listType);
+
+            this.beyondMaxLevels = 0;
+
+            // If the item is moved to the left, send it to its parent's level unless there are siblings below it.
+            if (parentItem != null && nextItem == null &&
+                (o.rtl && (this.positionAbs.left + this.helper.outerWidth() > parentItem.offset().left + parentItem.outerWidth()) ||
+                    !o.rtl && (this.positionAbs.left < parentItem.offset().left))) {
+                parentItem.after(this.placeholder[0]);
+                this._clearEmpty(parentItem[0]);
+                this._trigger("change", event, this._uiHash());
+            }
+            // If the item is below a sibling and is moved to the right, make it a child of that sibling.
+            else if (previousItem != null &&
+                (o.rtl && (this.positionAbs.left + this.helper.outerWidth() < previousItem.offset().left + previousItem.outerWidth() - o.tabSize) ||
+                    !o.rtl && (this.positionAbs.left > previousItem.offset().left + o.tabSize))) {
+                this._isAllowed(previousItem, level, level + childLevels + 1);
+                if (!previousItem.children(o.listType).length) {
+                    previousItem[0].appendChild(newList);
+                }
+                // If this item is being moved from the top, add it to the top of the list.
+                if (previousTopOffset && (previousTopOffset <= previousItem.offset().top)) {
+                    previousItem.children(o.listType).prepend(this.placeholder);
+                }
+                // Otherwise, add it to the bottom of the list.
+                else {
+                    previousItem.children(o.listType)[0].appendChild(this.placeholder[0]);
+                }
+                this._trigger("change", event, this._uiHash());
+            }
+            else {
+                this._isAllowed(parentItem, level, level + childLevels);
+            }
+
+            //Post events to containers
+            this._contactContainers(event);
+
+            //Interconnect with droppables
+            if ($.ui.ddmanager) $.ui.ddmanager.drag(this, event);
+
+            //Call callbacks
+            this._trigger('sort', event, this._uiHash());
+
+            this.lastPositionAbs = this.positionAbs;
+            return false;
+
+        },
+
+        _mouseStop: function (event, noPropagation) {
+
+            // If the item is in a position not allowed, send it back
+            if (this.beyondMaxLevels) {
+
+                this.placeholder.removeClass(this.options.errorClass);
+
+                if (this.domPosition.prev) {
+                    $(this.domPosition.prev).after(this.placeholder);
+                } else {
+                    $(this.domPosition.parent).prepend(this.placeholder);
+                }
+
+                this._trigger("revert", event, this._uiHash());
+
+            }
+
+            // Clean last empty ul/ol
+            for (var i = this.items.length - 1; i >= 0; i--) {
+                var item = this.items[i].item[0];
+                this._clearEmpty(item);
+            }
+
+            $.ui.sortable.prototype._mouseStop.apply(this, arguments);
+
+        },
+
+        serialize: function (options) {
+
+            var o = $.extend({}, this.options, options),
+                items = this._getItemsAsjQuery(o && o.connected),
+                str = [];
+
+            $(items).each(function () {
+                var res = ($(o.item || this).attr(o.attribute || 'id') || '')
+                        .match(o.expression || (/(.+)[-=_](.+)/)),
+                    pid = ($(o.item || this).parent(o.listType)
+                        .parent(o.items)
+                        .attr(o.attribute || 'id') || '')
+                        .match(o.expression || (/(.+)[-=_](.+)/));
+
+                if (res) {
+                    str.push(((o.key || res[1]) + '[' + (o.key && o.expression ? res[1] : res[2]) + ']')
+                        + '='
+                        + (pid ? (o.key && o.expression ? pid[1] : pid[2]) : o.rootID));
+                }
+            });
+
+            if (!str.length && o.key) {
+                str.push(o.key + '=');
+            }
+
+            return str.join('&');
+
+        },
+
+        toHierarchy: function (options) {
+
+            var o = $.extend({}, this.options, options),
+                sDepth = o.startDepthCount || 0,
+                ret = [];
+
+            $(this.element).children(o.items).each(function () {
+                var level = _recursiveItems(this);
+                ret.push(level);
+            });
+
+            return ret;
+
+            function _recursiveItems(item) {
+                var id = ($(item).attr(o.attribute || 'id') || '').match(o.expression || (/(.+)[-=_](.+)/));
+                if (id) {
+                    var currentItem = {"id": id[2]};
+                    if ($(item).children(o.listType).children(o.items).length > 0) {
+                        currentItem.children = [];
+                        $(item).children(o.listType).children(o.items).each(function () {
+                            var level = _recursiveItems(this);
+                            currentItem.children.push(level);
+                        });
+                    }
+                    return currentItem;
+                }
+            }
+        },
+
+        toArray: function (options) {
+
+            var o = $.extend({}, this.options, options),
+                sDepth = o.startDepthCount || 0,
+                ret = [],
+                left = 2;
+
+            ret.push({
+                "item_id": o.rootID,
+                "parent_id": 'none',
+                "depth": sDepth,
+                "left": '1',
+                "right": ($(o.items, this.element).length + 1) * 2
+            });
+
+            $(this.element).children(o.items).each(function () {
+                left = _recursiveArray(this, sDepth + 1, left);
+            });
+
+            ret = ret.sort(function (a, b) {
+                return (a.left - b.left);
+            });
+
+            return ret;
+
+            function _recursiveArray(item, depth, left) {
+
+                var right = left + 1,
+                    id,
+                    pid;
+
+                if ($(item).children(o.listType).children(o.items).length > 0) {
+                    depth++;
+                    $(item).children(o.listType).children(o.items).each(function () {
+                        right = _recursiveArray($(this), depth, right);
+                    });
+                    depth--;
+                }
+
+                id = ($(item).attr(o.attribute || 'id')).match(o.expression || (/(.+)[-=_](.+)/));
+
+                if (depth === sDepth + 1) {
+                    pid = o.rootID;
+                } else {
+                    var parentItem = ($(item).parent(o.listType)
+                        .parent(o.items)
+                        .attr(o.attribute || 'id'))
+                        .match(o.expression || (/(.+)[-=_](.+)/));
+                    pid = parentItem[2];
+                }
+
+                if (id) {
+                    ret.push({"item_id": id[2], "parent_id": pid, "depth": depth, "left": left, "right": right});
+                }
+
+                left = right + 1;
+                return left;
+            }
+
+        },
+
+        _clearEmpty: function (item) {
+
+            var emptyList = $(item).children(this.options.listType);
+            if (emptyList.length && !emptyList.children().length && !this.options.doNotClear) {
+                emptyList.remove();
+            }
+
+        },
+
+        _getLevel: function (item) {
+
+            var level = 1;
+
+            if (this.options.listType) {
+                var list = item.closest(this.options.listType);
+                while (list && list.length > 0 && !list.is('.ui-sortable')) {
+                    level++;
+                    list = list.parent().closest(this.options.listType);
+                }
+            }
+
+            return level;
+        },
+
+        _getChildLevels: function (parent, depth) {
+            var self = this,
+                o = this.options,
+                result = 0;
+            depth = depth || 0;
+
+            $(parent).children(o.listType).children(o.items).each(function (index, child) {
+                result = Math.max(self._getChildLevels(child, depth + 1), result);
+            });
+
+            return depth ? result + 1 : result;
+        },
+
+        _isAllowed: function (parentItem, level, levels) {
+            var o = this.options,
+                isRoot = $(this.domPosition.parent).hasClass('ui-sortable') ? true : false,
+                maxLevels = this.placeholder.closest('.ui-sortable').nestedSortable('option', 'maxLevels'); // this takes into account the maxLevels set to the recipient list
+
+            // Is the root protected?
+            // Are we trying to nest under a no-nest?
+            // Are we nesting too deep?
+            if (!o.isAllowed(this.currentItem, parentItem) ||
+                parentItem && parentItem.hasClass(o.disableNesting) ||
+                o.protectRoot && (parentItem == null && !isRoot || isRoot && level > 1)) {
+                this.placeholder.addClass(o.errorClass);
+                if (maxLevels < levels && maxLevels != 0) {
+                    this.beyondMaxLevels = levels - maxLevels;
+                } else {
+                    this.beyondMaxLevels = 1;
+                }
+            } else {
+                if (maxLevels < levels && maxLevels != 0) {
+                    this.placeholder.addClass(o.errorClass);
+                    this.beyondMaxLevels = levels - maxLevels;
+                } else {
+                    this.placeholder.removeClass(o.errorClass);
+                    this.beyondMaxLevels = 0;
+                }
+            }
+        }
+
+    }));
+
+    $.mjs.nestedSortable.prototype.options = $.extend({}, $.ui.sortable.prototype.options, $.mjs.nestedSortable.prototype.options);
+})(jQuery);

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: jquery-mjs-nestedSortable-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michael Sprauer
+- Manuele J Sarfatti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Features
+      Designed to work seamlessly with the nested set model (have a look at the toArray method)
+      Items can be sorted in their own list, moved across the tree, or nested under other items.
+      Sublists are created and deleted on the fly
+      All jQuery Sortable options, events and methods are available
+      It is possible to define elements that will not accept a new nested item/list and a maximum depth for nested items
+      The root level can be protected
+email:
+- Sprauer@Inline.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/jquery/mjs/nestedSortable/rails.rb
+- lib/jquery/mjs/nestedSortable/rails/version.rb
+- vendor/assets/javascripts/jquery.mjs.netsedSortable.js
+homepage: https://github.com/MichaelSp/jquery.mjs.nestedSortable-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: nestedSortable is a jQuery plugin for rails that extends jQuery Sortable
+  UI functionalities to nested lists.
+test_files: []