the_sortable_tree_mongoid 1.8.5

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2009-2012 Ilya N. Zykin, Matthew Clark
+
+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,302 @@
+### TheSortableTree
+
+Engine Based Drag&Drop GUI for awesome_nested_set gem. **Rails >= 3.1**
+
+School teacher came to help! TaDa! ;)
+
+**Drag&Drop sortable tree**
+
+![TheSortableTree](https://github.com/the-teacher/the_sortable_tree/raw/master/pic.jpg)
+
+**Simple nested sets (__min__ option)**
+
+![TheSortableTree](https://github.com/the-teacher/the_sortable_tree/raw/master/pic_min.jpg)
+
+**sortable_tree** - recursive helper-method for render sortable awesome_nested_set tree.
+
+**sortable_tree** uses partials for rendering, that's why it is **so easy to customize**!
+
+### List of available variants of rendering 
+
+* Drag&Drop sortable tree
+* Simple nested sets (**min** option)
+* Nested sets with expand/collapse animation (**expand** option) [under development]
+* Nested comments (**comments** option) [under development]
+
+### Can I use gem with Rails 2 or Rails 3.0?
+
+Take files from the gem and put it in your rails 2 application.
+
+View helper and view files does not depend on the version of rails.
+
+Copy and Paste rebuild function from TheSortableTreeController.
+
+Perhaps, you may have to slightly change the function of the controller.
+
+### Changelog
+
+1.8.5 - helper can rendering a part tree
+
+1.8.0 - stable release
+
+### Is it fast?
+
+Hmmmm...
+
+* Development env
+* 584 elements
+* 3 levels deep
+
+Rendered by 50 sec.
+
+I think it is good result for rendering by partials.
+
+Can you makes it faster? Welcome!
+
+### ERB vs HAML vs SLIM
+
+So, ERB and SLIM fans want to make gem independent of HAML.
+
+Ok, let it be. But you will convert view partials youself. It's my revenge ;)
+
+Read project wiki for looking ERB partials
+
+**By default I'm use HAML, and now you should define it manually in your Gemfile.**
+
+### Install
+
+    gem 'haml'
+    gem 'awesome_nested_set' # gem 'nested_set'
+    gem 'the_sortable_tree'
+
+bundle
+
+### Require
+
+1. gem 'nested_set' or gem 'awesome_nested_set'
+2. gem 'haml'
+3. JQuery UI
+
+### Example of using with Page Model
+
+### Jquery
+
+**app/assets/javascripts/application.js**
+
+``` ruby
+//= require jquery
+//= require jquery-ui
+//= require jquery_ujs
+```
+
+### Extend your Model
+
+``` ruby
+class Page < ActiveRecord::Base
+  include TheSortableTree::Scopes
+  # any code here
+end
+```
+
+### Extend your Controller
+
+``` ruby
+class PagesController < ApplicationController
+  include TheSortableTreeController::Rebuild
+  # any code here
+end
+```
+
+or (for reversed tree)
+
+``` ruby
+class PagesController < ApplicationController
+  include TheSortableTreeController::ReversedRebuild
+  # any code here
+end
+```
+
+### Extend your Routes
+
+``` ruby
+resources :pages do
+  collection do
+    get :manage
+    post :rebuild
+  end
+end
+```
+
+**manage** action or any else action for show sortable tree
+
+**rebuild** action is _required_ action for correctly work of **the_sortable_tree**
+
+### Find your tree
+
+``` ruby
+class PagesController < ApplicationController
+  include TheSortableTreeController::Rebuild
+
+  def manage
+    @pages = Page.nested_set.all
+  end
+
+  # any code here
+end
+
+```
+
+or 
+
+``` ruby
+class PagesController < ApplicationController
+  include TheSortableTreeController::ReversedRebuild
+
+  def manage
+    @pages = Page.reversed_nested_set.all
+  end
+  
+  # any code here
+end
+```
+
+### Render your tree with TheSortableTree (Haml markup)
+
+``` ruby
+- content_for :css do
+  = stylesheet_link_tag 'the_sortable_tree', :media => :screen
+- content_for :js do
+  = javascript_include_tag 'jquery.ui.nestedSortable'
+
+= sortable_tree @pages, :new_url => new_page_path, :max_levels => 4
+```
+
+or (without administrator controls and drag&drop)
+
+``` ruby
+- content_for :css do
+  = stylesheet_link_tag 'the_sortable_tree_min', :media => :screen
+
+= sortable_tree @pages, :new_url => new_page_path, :path => 'the_sortable_tree_min'
+```
+
+### Customize tree for User (min version)
+
+**Use sortable_tree as view helper for simple rendering of nested_set tree**
+
+``` ruby
+rails g the_sortable_tree:views pages min
+```
+
+It's will generate minimal set of view partials for **sortable_tree** helper
+
+``` ruby
+create  app/views/pages/the_sortable_tree_min
+create  app/views/pages/the_sortable_tree_min/_children.html.haml
+create  app/views/pages/the_sortable_tree_min/_node.html.haml
+create  app/views/pages/the_sortable_tree_min/_link.html.haml
+create  app/views/pages/the_sortable_tree_min/_tree.html.haml
+```
+
+Just use it or Customize and use it!
+
+``` ruby
+- content_for :css do
+  = stylesheet_link_tag 'the_sortable_tree_min', :media => :screen
+= sortable_tree @pages, :new_url => new_page_path, :path => 'pages/the_sortable_tree_min'
+```
+
+### Customize tree for Administrator (full version)
+
+``` ruby
+rails g the_sortable_tree:views pages
+```
+
+It's will generate view partials for **sortable_tree** helper
+
+``` ruby
+create  app/views/pages/the_sortable_tree
+create  app/views/pages/the_sortable_tree/_controls.html.haml
+create  app/views/pages/the_sortable_tree/_node.html.haml
+create  app/views/pages/the_sortable_tree/_js_init_sortable_tree.html.haml
+create  app/views/pages/the_sortable_tree/_js_on_update_tree.html.haml
+create  app/views/pages/the_sortable_tree/_js_rebuild_ajax.html.haml
+create  app/views/pages/the_sortable_tree/_link.html.haml
+create  app/views/pages/the_sortable_tree/_children.html.haml
+create  app/views/pages/the_sortable_tree/_new.html.haml
+create  app/views/pages/the_sortable_tree/_tree.html.haml
+```
+
+Customize and use it!
+
+``` ruby
+- content_for :css do
+  = stylesheet_link_tag 'the_sortable_tree', :media => :screen
+- content_for :js do
+  = javascript_include_tag 'jquery.ui.nestedSortable'
+
+= sortable_tree @pages, :new_url => new_page_path, :path => 'pages/the_sortable_tree', :max_levels => 2
+```
+
+### Rendering a part of tree
+
+``` ruby
+@root  = Page.root
+@pages = @root.descendants.nested_set.all
+```
+
+``` ruby
+= @root.inspect
+= sortable_tree @pages, :new_url => new_page_path
+```
+
+### LiveDemo
+
+https://github.com/the-teacher/the_sortable_tree_test_app
+
+### Options
+
+**id** - id field (:id => :friendly_id etc. **:id** by default)
+
+**title** - title field of node (:title => :name etc. **:title** by default)
+
+**path** - path to custom view partials (:path => 'pages/the_sortable_tree')
+
+**max_levels** - how many draggable levels can be? (**3** by default). **Can't be 0 (zero) and negative**
+
+**namespace** - namespace for admin sections for example. (:namespace => :admin, **:namespace** => nil by default)
+
+**opts[:level]** - view helper define level of recursion for each node. You can call **opts[:level]** into view partials
+
+### Partials
+
+**_tree** - root container for nested set elements
+
+**_node** - element of tree (link to current node and nested set of children)
+
+**_link** - decoration of link to current element of tree
+
+**_children** - decoration of children
+
+**_new** - create new element link
+
+**_controls** - control elements for current node
+
+
+**_js_init_sortable_tree** - JS for sortable tree
+
+**_js_on_update_tree**- JS for sortable tree
+
+**_js_rebuild_ajax**- JS for sortable tree
+
+### Contributors
+
+* https://github.com/the-teacher
+* https://github.com/winescout
+* https://github.com/gbrain
+* https://github.com/Mik-die
+
+### Acknowledgments
+
+* https://github.com/mjsarfatti/nestedSortable
+* http://iconza.com

data/Rakefile

@@ -0,0 +1,37 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'TheSortableTree'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+
+require 'rspec/rails'
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+end
+
+task :default => :test

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

@@ -0,0 +1,356 @@
+/*
+ * jQuery UI Nested Sortable
+ * v 1.3.4 / 28 apr 2011
+ * http://mjsarfatti.com/sandbox/nestedSortable
+ *
+ * Depends:
+ *	 jquery.ui.sortable.js 1.8+
+ *
+ * License CC BY-SA 3.0
+ * Copyright 2010-2011, Manuele J Sarfatti
+ */
+
+(function($) {
+
+	$.widget("ui.nestedSortable", $.extend({}, $.ui.sortable.prototype, {
+
+		options: {
+			tabSize: 20,
+			disableNesting: 'ui-nestedSortable-no-nesting',
+			errorClass: 'ui-nestedSortable-error',
+			listType: 'ol',
+			maxLevels: 0,
+			noJumpFix: 0
+		},
+
+		_create: function(){
+			if (this.noJumpFix == false)
+				this.element.height(this.element.height());
+			this.element.data('sortable', this.element.data('nestedSortable'));
+			return $.ui.sortable.prototype._create.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;
+			}
+
+			//Do scrolling
+			if(this.options.scroll) {
+				var o = this.options, 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");
+
+			//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
+				) {
+
+					this.direction = intersection == 1 ? "down" : "up";
+
+					if (this.options.tolerance == "pointer" || this._intersectsWithSides(item)) {
+						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;
+			var level = this._getLevel(this.placeholder);
+			var childLevels = this._getChildLevels(this.helper);
+			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]) {
+					if (previousItem[0].previousSibling) {
+						previousItem = $(previousItem[0].previousSibling);
+					} else {
+						previousItem = null;
+						break;
+					}
+				}
+			}
+
+			newList = document.createElement(o.listType);
+
+			this.beyondMaxLevels = 0;
+
+			// If the item is moved to the left, send it to its parent level
+			if (parentItem != null && 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 another one and is moved to the right, make it a children of it
+			else if (previousItem != null && this.positionAbs.left > previousItem.offset().left + o.tabSize) {
+				this._isAllowed(previousItem, level+childLevels+1);
+				if (!previousItem.children(o.listType).length) {
+					previousItem[0].appendChild(newList);
+				}
+				previousItem.children(o.listType)[0].appendChild(this.placeholder[0]);
+				this._trigger("change", event, this._uiHash());
+			}
+			else {
+				this._isAllowed(parentItem, 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) {
+				var parent = this.placeholder.parent().closest(this.options.items);
+				
+				for (var i = this.beyondMaxLevels - 1; i > 0; i--) {
+					parent = parent.parent().closest(this.options.items);
+				}
+
+				this.placeholder.removeClass(this.options.errorClass);
+				parent.after(this.placeholder);
+				this._trigger("change", event, this._uiHash());
+			}
+
+			$.ui.sortable.prototype._mouseStop.apply(this, arguments);
+
+		},
+
+		serialize: function(o) {
+
+			var items = this._getItemsAsjQuery(o && o.connected);
+			var str = []; o = o || {};
+
+			$(items).each(function() {
+				var res = ($(o.item || this).attr(o.attribute || 'id') || '').match(o.expression || (/(.+)[-=_](.+)/));
+				var pid = ($(o.item || this).parent(o.listType).parent('li').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]) : 'root'));
+			});
+
+			if(!str.length && o.key) {
+				str.push(o.key + '=');
+			}
+
+			return str.join('&');
+
+		},
+
+		toHierarchy: function(o) {
+
+			o = o || {};
+			var sDepth = o.startDepthCount || 0;
+			var ret = [];
+
+			$(this.element).children('li').each(function() {
+				var level = _recursiveItems($(this));
+				ret.push(level);
+			});
+
+			return ret;
+
+			function _recursiveItems(li) {
+				var id = ($(li).attr(o.attribute || 'id') || '').match(o.expression || (/(.+)[-=_](.+)/));
+				if (id != null) {
+					var item = {"id" : id[2]};
+					if ($(li).children(o.listType).children('li').length > 0) {
+						item.children = [];
+						$(li).children(o.listType).children('li').each(function () {
+							var level = _recursiveItems($(this));
+							item.children.push(level);
+						});
+					}
+					return item;
+				}
+			}
+        },
+
+		toArray: function(o) {
+
+			o = o || {};
+			var sDepth = o.startDepthCount || 0;
+			var ret = [];
+			var left = 2;
+
+			ret.push({"item_id": 'root', "parent_id": 'none', "depth": sDepth, "left": '1', "right": ($('li', this.element).length + 1) * 2});
+
+			$(this.element).children('li').each(function () {
+				left = _recursiveArray(this, sDepth + 1, left);
+			});
+
+			function _sortByLeft(a,b) {
+				return a['left'] - b['left'];
+			}
+			ret = ret.sort(_sortByLeft);
+
+			return ret;
+
+			function _recursiveArray(item, depth, left) {
+
+				right = left + 1;
+
+				if ($(item).children(o.listType).children('li').length > 0) {
+					depth ++;
+					$(item).children(o.listType).children('li').each(function () {
+						right = _recursiveArray($(this), depth, right);
+					});
+					depth --;
+				}
+
+				id = ($(item).attr(o.attribute || 'id')).match(o.expression || (/(.+)[-=_](.+)/));
+
+				if (depth === sDepth + 1) pid = 'root';
+				else {
+					parentItem = ($(item).parent(o.listType).parent('li').attr('id')).match(o.expression || (/(.+)[-=_](.+)/));
+					pid = parentItem[2];
+				}
+
+				if (id != null) {
+						ret.push({"item_id": id[2], "parent_id": pid, "depth": depth, "left": left, "right": right});
+				}
+
+				return left = right + 1;
+			}
+
+		},
+
+		_clear: function(event, noPropagation) {
+
+			$.ui.sortable.prototype._clear.apply(this, arguments);
+
+			// 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);
+			}
+			return true;
+
+		},
+
+		_clearEmpty: function(item) {
+
+			if (item.children[1] && item.children[1].children.length == 0) {
+				item.removeChild(item.children[1]);
+			}
+
+		},
+
+		_getLevel: function(item) {
+
+			var level = 1;
+
+			if (this.options.listType) {
+					var list = item.closest(this.options.listType);
+					while (!list.is('.ui-sortable')/* && level < this.options.maxLevels*/) {
+							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, levels) {
+			var o = this.options
+			// Are we trying to nest under a no-nest or are we nesting too deep?
+			if (parentItem == null || !(parentItem.hasClass(o.disableNesting))) {
+				if (o.maxLevels < levels && o.maxLevels != 0) {
+					this.placeholder.addClass(o.errorClass);
+					this.beyondMaxLevels = levels - o.maxLevels;
+				} else {
+					this.placeholder.removeClass(o.errorClass);
+					this.beyondMaxLevels = 0;
+				}
+			} else {
+				this.placeholder.addClass(o.errorClass);
+				if (o.maxLevels < levels && o.maxLevels != 0) {
+					this.beyondMaxLevels = levels - o.maxLevels;
+				} else {
+					this.beyondMaxLevels = 1;
+				}
+			}
+		}
+
+	}));
+
+	$.ui.nestedSortable.prototype.options = $.extend({}, $.ui.sortable.prototype.options, $.ui.nestedSortable.prototype.options);
+})(jQuery);