constructor-core 0.9.1 → 1.0.0beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2877812b30ec4bd56ddfd1498fd1f953cc214d2d
-  data.tar.gz: d4684246ac4d6cbfc3efe8452445e05a96537514
+  metadata.gz: adbea170d2a6f81a42d4484fff1dcbc4e784bd31
+  data.tar.gz: fea77520947a5af5616c90751a35a8610b84919a
 SHA512:
-  metadata.gz: 9b34c0adceba550ce67746f01b6f012af6667b8ee58822919469e3c78cbcf3c72d62266f77e57f0715e629afd1c450f77d31f660240df8d38c7c3f0f208e2aa0
-  data.tar.gz: ea755a1de32131a6961151612a9f4e13eef04851ab844844ea3d814b323b357a73274103346e9b7137d1d8c1675aba0b18d24d123fe33ddc26c503c0d819340e
+  metadata.gz: 535db94846b950ba718ba22f09c1e90ec4bd9147fb404f77e759592645b3971af7a2c1ec406a73c3e6160b96152ecc5ed9eff25fd20bebca2e5664613f85a3b1
+  data.tar.gz: 357b1052969eeaece2f5669aa67d6c81b0a904d4866630950c7f59d6c3ccbf8c642a0d45e3c76bc1b0a115f8938ce62be1ac1eb08aff4634cbe58b28b24581c0

data/app/assets/javascripts/constructor_core/application.js.coffee

@@ -1,17 +1,14 @@
 #= require constructor_core/jquery_bundle
-#= require constructor_core/bootstrap
 #= require ckeditor/ckeditor
 #= require constructor_pages/urlify
+#= require ./jquery.ui.nestedSortable
+#= require ./sortable_tree/initializer
+#= require ./expandable_tree/hashchange
+#= require ./expandable_tree/restorable
+#= require ./expandable_tree/initializer
 #= require_self
 
 $(document).ready ->
-  $(".alert").alert()
-  $(".collapse").collapse()
-  
-  $('#url-if-empty').popover({
-    offset: 10
-  })
-
   $('.auto_url').hide()
   $('#page_url').hide()
 
@@ -20,33 +17,33 @@ $(document).ready ->
   unless auto_url
     auto_url_true()
 
-  $('#page_name').keyup -> $('.address').html(parameterize())
+  $('#page_name').keyup -> $('.b-full-url__url').html(parameterize())
   $('#page_parent_id').change ->
-    parent_full_url = $('#page_parent_id option:selected').data('full_url')
+    parent_full_url = $('#page_parent_id option:selected').data('b-full-url')
     if parent_full_url
-      $('.path').html(parent_full_url)
+      $('.b-full-url__path').html(parent_full_url)
     else
-      $('.path').html('')
+      $('.b-full-url__path').html('')
 
-  $('.address, .address_icon').click ->
+  $('.b-full-url__url, .b-full-url__icon').click ->
     if $('#page_auto_url').is(':checked') == true
       $('#page_url').prop('value', parameterize())
       auto_url_true()
     else
-      $('.address').html(parameterize())
+      $('.b-full-url__url').html(parameterize())
       auto_url_false()
 
 auto_url_true = ->
   $('#page_url').show()
   $('#page_auto_url').prop('checked', false)
-  $('.address_icon').addClass('icon-remove').removeClass('icon-pencil')
-  $('.address').hide()
+  $('.b-full-url__icon').addClass('fa-times-circle-o').removeClass('fa-pencil')
+  $('.b-full-url__url').hide()
 
 auto_url_false = ->
   $('#page_url').hide()
   $('#page_auto_url').prop('checked', true)
-  $('.address_icon').addClass('icon-pencil').removeClass('icon-remove')
-  $('.address').show()
+  $('.b-full-url__icon').addClass('fa-pencil').removeClass('fa-times-circle-o')
+  $('.b-full-url__url').show()
 
 parameterize = ->
   URLify($('#page_name').prop('value'))

data/app/assets/javascripts/constructor_core/expandable_tree/hashchange.js.coffee

@@ -0,0 +1,33 @@
+@_arrays_diff = (a, b) -> b.filter (i) -> return !(a.indexOf(i) > -1)
+
+@expandable_tree_hashchange = (hash_event) ->
+  if window.skip_expandable_tree_hashchange
+    window.skip_expandable_tree_hashchange = false
+    return true
+
+  hash_and_cookie_accordance()
+  
+  oEvent  = hash_event.originalEvent
+  new_url = oEvent.newURL
+  old_url = oEvent.oldURL
+
+  new_hash = new_url.split('#')[1]
+  old_hash = old_url.split('#')[1]
+
+  return false unless ('#'+new_hash).match(TSTconst.re()) or ('#'+old_hash).match(TSTconst.re())
+
+  new_arr = _nested_set_hash_arr(new_hash)
+  old_arr = _nested_set_hash_arr(old_hash)
+  
+  diff_ids = if new_arr.length >= old_arr.length
+    _arrays_diff(old_arr, new_arr)
+  else
+    _arrays_diff(new_arr, old_arr)
+
+  for id in diff_ids
+    btn = $("[data-node-id=#{id}] > .b-tree__item > .b-tree__expand")
+    btn.click()
+    setTimeout -> window.skip_expandable_tree_hashchange = false
+
+$(window).bind 'hashchange', (hash_event) ->
+  expandable_tree_hashchange(hash_event)

data/app/assets/javascripts/constructor_core/expandable_tree/initializer.js.coffee

@@ -0,0 +1,106 @@
+# ----------------------------------------
+# Restorable Helpers
+# ----------------------------------------
+@add_to_restorable_path = (node) ->
+  if window.is_restorable_tree
+    id = node.data('node-id')
+    nested_tree_path_add(id)
+    return true
+  false
+
+@remove_from_restorable_path = (node) ->
+  if window.is_restorable_tree
+    id = node.data('node-id')
+    nested_tree_path_remove(id)
+    return true
+  false
+
+# ----------------------------------------
+# Main Helpers
+# ----------------------------------------
+@nested_tree_toggle = (button) ->
+  if button.hasClass('b-tree__minus')
+    button.removeClass('b-tree__minus').addClass('b-tree__plus')
+    button.removeClass('fa-minus-square-o').addClass('fa-plus-square-o')
+  else
+    button.removeClass('b-tree__plus').addClass('b-tree__minus')
+    button.removeClass('fa-plus-square-o').addClass('fa-minus-square-o')
+
+@append_children_to_node = (node, html) ->
+  html = html.trim()
+  item = node.children('.b-tree__item')
+
+  button = node.children('.b-tree__item').children('.b-tree__expand')
+
+  if html.length is 0
+    button.addClass 'empty'
+
+  if html.length > 0
+    item.after html
+    nested_tree_toggle(button)
+    add_to_restorable_path(node)
+
+@upload_nodes_children = (node, expand_node_url) ->
+  node_id    = node.data('node-id')
+  tree       = $('.b-tree')
+  ctrl_items = $('.b-tree__handler, .b-tree__expand', tree)
+
+  $.ajax
+    type:     'POST'
+    dataType: 'html'
+    data:     { id: node_id }
+    url:      expand_node_url
+
+    beforeSend: (xhr) ->
+      ctrl_items.hide()
+      window.skip_expandable_tree_hashchange = true
+
+    success: (data, status, xhr) ->
+      ctrl_items.show()
+      append_children_to_node(node, data)
+
+    error: (xhr, status, error) ->
+      try
+        console.log error
+
+@init_expandable_tree = ->
+  sortable_tree = $('.b-tree')
+  return false if sortable_tree.length is 0
+
+  window.is_restorable_tree         ||= false
+  window.is_cookie_restoreable_tree   = sortable_tree.data('cookie_store') || sortable_tree.data('cookie-store')
+
+  if window.is_cookie_restoreable_tree
+    steps = $.cookie(TSTconst.cookie_name())
+    _set_hash(TSTconst.hash_prefix() + steps) if steps
+
+  expand_node_url = sortable_tree.data('expand_node_url') || sortable_tree.data('expand-node-url')
+
+  # Now it's designed only for one tree
+  restore_nested_tree(sortable_tree, expand_node_url) if window.is_restorable_tree
+
+  sortable_tree.on 'click', '.b-tree__minus', (e) ->
+    button = $ @
+    node   = button.parent().parent()
+    nested_tree_toggle(button)
+    remove_from_restorable_path(node)
+    node.children('.b-tree__nested-set').hide()
+    false
+
+  sortable_tree.on 'click', '.b-tree__plus', (e) ->
+    button     = $ @
+    node       = button.parent().parent()
+    nested_set = node.children('.b-tree__nested-set')
+
+    if nested_set.length is 0
+      upload_nodes_children(node, expand_node_url)
+    else
+      nested_set.show()
+      nested_tree_toggle(button)
+      add_to_restorable_path(node)
+
+    false
+
+  true
+
+$ -> init_expandable_tree()

data/app/assets/javascripts/constructor_core/expandable_tree/jquery.cookie.coffee

@@ -0,0 +1,68 @@
+#!
+# * jQuery Cookie Plugin v1.3.1
+# * https://github.com/carhartl/jquery-cookie
+# *
+# * Copyright 2013 Klaus Hartl
+# * Released under the MIT license
+# 
+((factory) ->
+  if typeof define is "function" and define.amd
+    # AMD. Register as anonymous module.
+    define ["jquery"], factory
+  else
+    # Browser globals.
+    factory jQuery
+) ($) ->
+  pluses = /\+/g
+
+  raw     = (s) -> s
+  decoded = (s) -> decodeURIComponent s.replace(pluses, " ")
+  converted = (s) ->
+    # This is a quoted cookie as according to RFC2068, unescape
+    s = s.slice(1, -1).replace(/\\"/g, "\"").replace(/\\\\/g, "\\")  if s.indexOf("\"") is 0
+    try
+      return (if config.json then JSON.parse(s) else s)
+
+  
+  config = $.cookie = (key, value, options) ->
+    # write
+    if value isnt `undefined`
+      options = $.extend({}, config.defaults, options)
+      
+      if typeof options.expires is "number"
+        days = options.expires
+        t    = options.expires = new Date()
+        t.setDate t.getDate() + days
+      
+      value = (if config.json then JSON.stringify(value) else String(value))
+      
+      # use expires attribute, max-age is not supported by IE
+      return (document.cookie = [(if config.raw then key else encodeURIComponent(key)), "=", (if config.raw then value else encodeURIComponent(value)), (if options.expires then "; expires=" + options.expires.toUTCString() else ""), (if options.path then "; path=" + options.path else ""), (if options.domain then "; domain=" + options.domain else ""), (if options.secure then "; secure" else "")].join(""))
+    
+    # read
+    decode  = (if config.raw then raw else decoded)
+    cookies = document.cookie.split("; ")
+    result  = (if key then `undefined` else {})
+
+    i = 0
+    l = cookies.length
+
+    while i < l
+      parts  = cookies[i].split("=")
+      name   = decode parts.shift()
+      cookie = decode parts.join("=")
+      if key and key is name
+        result = converted(cookie)
+        break
+      result[name] = converted(cookie)  unless key
+      i++
+    result
+
+  config.defaults = {}
+
+  $.removeCookie = (key, options) ->
+    if $.cookie(key) isnt `undefined`
+      # Must not alter options, thus extending a fresh object...
+      $.cookie key, '', $.extend({}, options, expires: -1)
+      return true
+    false

data/app/assets/javascripts/constructor_core/expandable_tree/restorable.js.coffee

@@ -0,0 +1,122 @@
+window.is_restorable_tree = true
+
+class @TSTconst
+  @_name        = 'TST'
+  @delimiter    = ';'
+  @separator    = '|'
+  @re           = -> new RegExp(@cookie_name() + '\\' + @separator)
+  @hash_prefix  = -> @cookie_name() + @separator
+  @cookie_scope = -> $('.b-tree').data('cookie_scope') || $('.b-tree').data('cookie-scope')
+  @cookie_name  = ->
+    return @_name unless @cookie_scope()
+    @_name + '_' + @cookie_scope()
+
+# ====================================
+# Helpers
+# ====================================
+@_get_hash = -> document.location.hash
+@_set_hash = (str) ->
+  window.skip_expandable_tree_hashchange = true
+  document.location.hash = str
+
+@_uniqueArray = (arr = []) ->
+  output = {}
+  output[item] = item for item in arr
+  val for key, val of output
+
+@_compactArray = (array) -> array.filter (e) -> return e
+
+@_nested_set_hash_arr = (hash) ->
+    return [] unless hash
+    [prefix, arr] = hash.split(TSTconst.separator)
+    _compactArray _uniqueArray arr.split(TSTconst.delimiter)
+
+# ====================================
+# Helpers Fn
+# ====================================
+@nested_tree_get_path = ->
+  hash = _get_hash()
+  return false unless hash.match(TSTconst.re())
+  _nested_set_hash_arr(hash)
+
+@hash_and_cookie_accordance = ->
+  if window.is_cookie_restoreable_tree
+    hash = _get_hash()
+    if hash.length is 0
+      $.removeCookie( TSTconst.cookie_name() )
+    else
+      return false unless hash.match(TSTconst.re())
+      str = hash.split(TSTconst.separator)[1]
+      $.cookie(TSTconst.cookie_name(), str, { expires: 14 })
+
+  false
+
+@nested_tree_path_remove = (id) ->
+  hash  = _get_hash()
+  return false unless hash.match(TSTconst.re())
+
+  arr   = _nested_set_hash_arr(hash)
+  index = arr.indexOf(id+'')
+  return hash_and_cookie_accordance() if index is -1
+
+  arr.splice(index, 1)
+  str = _uniqueArray(arr).join(TSTconst.delimiter)
+
+  if str.length is 0
+    _set_hash('')
+  else
+    _set_hash(TSTconst.hash_prefix() + str)
+  
+  hash_and_cookie_accordance()
+
+  true
+
+@nested_tree_path_add = (id) ->
+  str  = id
+  hash = _get_hash()
+
+  if hash.match(TSTconst.re())
+    arr = _nested_set_hash_arr(hash)
+    arr.push(id)
+    arr = _uniqueArray arr
+    str = arr.join(TSTconst.delimiter)
+
+  _set_hash(TSTconst.hash_prefix() + str)
+  hash_and_cookie_accordance()
+
+# ====================================
+# Restore Fn
+# ====================================
+@load_nested_nodes = (arr, expand_node_url) ->
+  if arr.length is 0
+    window.skip_expandable_tree_hashchange = false
+    return false
+
+  id         = arr.shift()
+  tree       = $('.b-tree')
+  node       = $("[data-node-id=#{id}]")
+
+  if node.length is 0
+    load_nested_nodes(arr, expand_node_url)
+  else
+    $.ajax
+      type:     'POST'
+      dataType: 'html'
+      data:     { id: id }
+      url:      expand_node_url
+
+      beforeSend: (xhr) ->
+        window.skip_expandable_tree_hashchange = true
+
+      success: (data, status, xhr) ->
+        append_children_to_node(node, data)
+        load_nested_nodes(arr, expand_node_url)
+
+      error: (xhr, status, error) ->
+        try
+          console.log error
+
+@restore_nested_tree = (sortable_tree, expand_node_url) ->
+  arr  = nested_tree_get_path()
+  return false unless arr
+  load_nested_nodes(arr, expand_node_url)

data/app/assets/javascripts/constructor_core/jquery.ui.nestedSortable.js

@@ -0,0 +1,429 @@
+/*
+ * 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);