sortable_element_for_nested_set 0.1.3

data/Manifest

@@ -0,0 +1,29 @@
+tasks/sortable_element_for_nested_set_tasks.rake
+init.rb
+lib/tree_calc.rb
+lib/sortable_element_for_nested_set.rb
+lib/sortable_element_for_nested_set_helper.rb
+README.rdoc
+Rakefile
+spec/helpers/sortable_element_for_nested_set_helper_spec.rb
+spec/railsenv/app/controllers/application_controller.rb
+spec/railsenv/config/routes.rb
+spec/railsenv/config/initializers/backtrace_silencers.rb
+spec/railsenv/config/initializers/mime_types.rb
+spec/railsenv/config/initializers/inflections.rb
+spec/railsenv/config/initializers/session_store.rb
+spec/railsenv/config/initializers/new_rails_defaults.rb
+spec/railsenv/config/environment.rb
+spec/railsenv/config/locales/en.yml
+spec/railsenv/config/boot.rb
+spec/railsenv/config/database.yml
+spec/railsenv/config/environments/development.rb
+spec/railsenv/config/environments/test.rb
+spec/railsenv/config/environments/production.rb
+spec/railsenv/db/test.sqlite3
+spec/spec_helper.rb
+spec/sortable_element_for_nested_set_spec.rb
+spec/spec.opts
+spec/controllers/sorting_controller_spec.rb
+spec/models/tree_move_calculator_spec.rb
+Manifest

data/README.rdoc

@@ -0,0 +1,71 @@
+= SortableElementForNestedSet
+
+Sorting a tree using the script.aculo.us helper that comes with Rails is nice.
+But if your tree is backed by a nested set, the default request parameter sent to 
+your controllers might not really fit your needs. 
+
+This plugin allows you to easily find out which html element was moved (dragged) and
+between which two elements it ended up. 
+
+Your work will be to make the update to your nested set model.
+
+=== Usage
+The plugin has two parts. One view helper method and one controller module.
+
+Assuming you have a tree where the node elements are named using the dom_id helper method,
+in your view, use the sortable_element_reporting_target helper pretty much as your would 
+use the sortable_element helper that comes with Rails.
+There is however a second argument that sets the parameter name of where the (record) id of 
+the element that was moved will be available.
+The third (optional) options argument is the same as for sortable_element, except that 
+<tt>:onChange</tt> and <tt>:with</tt> are not allowed. 
+
+<tt>
+<%= sortable_element_reporting_target("tree_element", "moved_element_id") %>
+</tt>
+
+In your controller, include the util methods with <tt>handles_sorting_of_nested_set</tt>.
+To get the new position of a moved element use the these methods in a similar way 
+to this example controller:
+
+
+	class MyController < ApplicationController
+	  handles_sorting_of_nested_set
+	  
+	  def move
+	    new_position = position_of(:moved_element_id).in_tree(:tree_element)
+	  end
+	end
+	
+
+The new_position variable will be a hash with information about the moved elements new position.
+The keys in the hash (<tt>:parent, :move_to_right_of, :move_to_left_of</tt>) all point to active 
+record id:s. It up to you to move your model accordingly.
+
+For a more complete sample, the relevant parts of a simple rails application can be found 
+in this gist[http://gist.github.com/128779].
+
+
+=== Install
+
+==== As gem
+
+Add the following to config/environment.rb
+
+	config.gem "robinsp-sortable_element_for_nested_set",
+	           :lib    => "sortable_element_for_nested_set",
+	           :source => "http://gems.github.com"
+
+Then run 
+
+<tt>sudo rake gems:install</tt>
+
+==== As plugin
+
+<tt>./script/plugin install git://github.com/robinsp/sortable_element_for_nested_set.git</tt>
+
+
+
+
+
+Copyright (c) 2009 RobinSpainhour.com, released under the MIT license

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rake'
+require 'spec/rake/spectask'
+require 'echoe'
+
+Echoe.new('sortable_element_for_nested_set', '0.1.3') do |p|
+  p.description    = "Rails plugin for using script.aculo.us sortable_element for trees backed by nested sets."
+  p.url            = "http://github.com/robinsp/sortable_element_for_nested_set"
+  p.author         = "Robin Spainhour"
+  p.email          = "robin@robinspainhour.com"
+  p.ignore_pattern = ["tmp/*"]
+  p.development_dependencies = ["rspec >= 1.2.4", 
+                                "rspec-rails >= 1.2.4",
+                                "mocha >= 0.9.5"]
+end
+
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Run the specs'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--colour --format progress --loadby mtime --reverse']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

data/init.rb

@@ -0,0 +1,2 @@
+require 'sortable_element_for_nested_set'
+require 'sortable_element_for_nested_set_helper'

data/lib/sortable_element_for_nested_set.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + "/tree_calc")
+require File.expand_path(File.dirname(__FILE__) + "/sortable_element_for_nested_set_helper")
+
+# SortableElementForNestedSet
+module SortableElementForNestedSet
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods 
+    def handles_sorting_of_nested_set
+      include SortableElementForNestedSet::InstanceMethods
+      attr_reader :dragged_record_id
+    end
+  end
+  
+  module InstanceMethods
+    protected
+    
+    def position_of(record_id_param_name)
+      @dragged_record_id = params[record_id_param_name].to_i
+      self
+    end
+    
+    def in_tree(tree_param_name)
+      calculator = TreeMoveCalculator.new( params[tree_param_name] )
+      calculator.placement_of(self.dragged_record_id)
+    end
+  end
+  
+end
+
+ActionController::Base.send( :include, SortableElementForNestedSet)

data/lib/sortable_element_for_nested_set_helper.rb

@@ -0,0 +1,41 @@
+module SortableElementForNestedSetHelper
+  
+  class OptsGenerator
+    attr_reader :element_id, :param_name
+    
+    def initialize(element_id, target_param_name)
+      raise "Arg error" if element_id.blank? || target_param_name.blank?
+      @element_id = element_id
+      @param_name = target_param_name
+    end
+    
+    def with_value
+      "'#{@param_name}='+ $(#{@element_id.to_json}).moved_element.split('_').last() + '&' + Sortable.serialize(#{@element_id.to_json})"
+    end
+    
+    def on_change_value 
+      "function(e) { $('#{@element_id}').moved_element = e.id; }"
+    end
+    
+    def opts
+      {:with => with_value, :onChange => on_change_value}
+    end
+  end
+
+  def sortable_element_reporting_target(element_id, target_param_name, options = {}) 
+    javascript_tag(sortable_element_reporting_target_js(element_id, target_param_name, options) )
+  end
+  
+  def sortable_element_reporting_target_js(element_id, target_param_name, options = {}) 
+    raise "target_param_name is required" if target_param_name.blank?
+    
+    [:onChange, :with].each do |key|
+      raise "#{key} is set by this helper and is not allowed" if options.has_key? key  
+    end
+    opts_gen = OptsGenerator.new(element_id, target_param_name)
+    
+    sortable_element_js(element_id, options.merge(opts_gen.opts))
+  end
+end
+
+ActionView::Base.send(:include, SortableElementForNestedSetHelper)

data/lib/tree_calc.rb

@@ -0,0 +1,136 @@
+module SortableElementForNestedSet
+  # Calculate the new position of a moved tree within a nested set.
+  # The new placement and sort order is given as a hash, as created by draggable_element 
+  # Javascript helper.
+  class TreeMoveCalculator
+    attr_reader :nodes
+    
+    # Calculate the left, right and parent values from 
+    # the parameter generated by draggable_element JS helper
+    def initialize(sort_order)
+      @nodes = TreeMoveCalculator.create_tree_nodes(sort_order)
+    end
+    
+    def right_of(target_id)
+      array_with_target_node = find_array_with_target_node(target_id)
+  
+      if (array_with_target_node.last.id == target_id)
+        return nil
+      else 
+        return array_with_target_node[array_with_target_node.collect(&:id).index(target_id) + 1].id
+      end
+    end
+    
+    def placement_of(target_id)
+      # Note that this swaps left and right as the consumer views it differently.
+      
+      {:parent => parent_of(target_id),
+       :move_to_right_of => left_of(target_id),
+       :move_to_left_of => right_of(target_id) }
+    end
+    
+    def left_of(target_id)
+      array_with_target_node = find_array_with_target_node(target_id)
+      
+      if (array_with_target_node.first.id == target_id)
+        return nil
+      else 
+        return array_with_target_node[array_with_target_node.collect(&:id).index(target_id) - 1].id
+      end
+    end
+      
+    def parent_of(val_to_find) 
+      return nil if @nodes.collect(&:id).include?(val_to_find)
+  
+      parent = nil
+      
+      @nodes.each do |node|
+        parent = find_parent_of(val_to_find, node)
+        return parent if parent
+      end
+    end
+  
+    # Create Array of TreeNodes from the parameter generated by draggable_element JS helper.
+    def self.create_tree_nodes(tree)
+      tree = to_hash(tree) if tree.is_a?(Array)
+      
+      result = []
+      
+      tree.keys.sort.each do |key|
+        node = TreeNode.new(tree[key]["id"].to_i)
+        node.children = create_tree_nodes( tree[key].reject {|k, v| k == "id"} )  if tree[key].many?
+        result << node
+      end
+      
+      return result
+    end
+    
+    # Convert an array of ids to the required hash format. 
+    def self.to_hash(array)
+      result = {}
+      
+      array.each_with_index {|id, i| result[i.to_s] = {"id" => id.to_s } }
+      
+      return result
+    end
+  
+  private  
+    def root?(target_id)
+      parent = parent_of(target_id)
+      parent.nil?
+    end
+    
+    def find_array_with_target_node(target_id)
+      unless root?(target_id)
+        parent_node_of(target_id).children
+      else
+        @nodes
+      end
+    end
+  
+    def parent_node_of(target_id)
+      parent_node = (flattened_nodes.select {|x| x.id == parent_of(target_id) }).first
+    end
+    
+    def flattened_nodes
+      @flattened_nodes ||= flatten_node_tree(@nodes).flatten
+    end
+    
+    def find_parent_of(val_to_find, node)
+      return node.id if node.children.collect(&:id).include?(val_to_find)
+         
+      parent = nil 
+      node.children.each do |child|
+        parent = find_parent_of(val_to_find, child)
+        return parent if parent
+      end
+      
+      return nil
+    end
+    
+    def flatten_node_tree(nodes) 
+      result = []
+      result << nodes
+      
+      (nodes.select{|x| !x.children.empty?}).each {|x| result << flatten_node_tree(x.children)}
+      return result 
+    end
+  
+  end
+
+  class TreeNode
+    attr_accessor :id, :children, :parent_id
+    attr_accessor :left, :right
+    
+    def initialize(id, children = nil)
+      @id = id
+      @children = children.nil? ? [] : children
+    end
+    
+    def children=(new_children)
+      new_children.each {|c| c.parent_id = self.id }
+      @children = new_children
+    end
+  end
+
+end

data/sortable_element_for_nested_set.gemspec

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sortable_element_for_nested_set}
+  s.version = "0.1.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Robin Spainhour"]
+  s.date = %q{2009-05-29}
+  s.description = %q{Rails plugin for using script.aculo.us sortable_element for trees backed by nested sets.}
+  s.email = %q{robin@robinspainhour.com}
+  s.extra_rdoc_files = ["tasks/sortable_element_for_nested_set_tasks.rake", "lib/tree_calc.rb", "lib/sortable_element_for_nested_set.rb", "lib/sortable_element_for_nested_set_helper.rb", "README.rdoc"]
+  s.files = ["tasks/sortable_element_for_nested_set_tasks.rake", "init.rb", "lib/tree_calc.rb", "lib/sortable_element_for_nested_set.rb", "lib/sortable_element_for_nested_set_helper.rb", "README.rdoc", "Rakefile", "spec/helpers/sortable_element_for_nested_set_helper_spec.rb", "spec/railsenv/app/controllers/application_controller.rb", "spec/railsenv/config/routes.rb", "spec/railsenv/config/initializers/backtrace_silencers.rb", "spec/railsenv/config/initializers/mime_types.rb", "spec/railsenv/config/initializers/inflections.rb", "spec/railsenv/config/initializers/session_store.rb", "spec/railsenv/config/initializers/new_rails_defaults.rb", "spec/railsenv/config/environment.rb", "spec/railsenv/config/locales/en.yml", "spec/railsenv/config/boot.rb", "spec/railsenv/config/database.yml", "spec/railsenv/config/environments/development.rb", "spec/railsenv/config/environments/test.rb", "spec/railsenv/config/environments/production.rb", "spec/railsenv/db/test.sqlite3", "spec/spec_helper.rb", "spec/sortable_element_for_nested_set_spec.rb", "spec/spec.opts", "spec/controllers/sorting_controller_spec.rb", "spec/models/tree_move_calculator_spec.rb", "Manifest", "sortable_element_for_nested_set.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/robinsp/sortable_element_for_nested_set}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Sortable_element_for_nested_set", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{sortable_element_for_nested_set}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Rails plugin for using script.aculo.us sortable_element for trees backed by nested sets.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 0", "= 1.2.4"])
+      s.add_development_dependency(%q<rspec-rails>, [">= 0", "= 1.2.4"])
+      s.add_development_dependency(%q<mocha>, [">= 0", "= 0.9.5"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0", "= 1.2.4"])
+      s.add_dependency(%q<rspec-rails>, [">= 0", "= 1.2.4"])
+      s.add_dependency(%q<mocha>, [">= 0", "= 0.9.5"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0", "= 1.2.4"])
+    s.add_dependency(%q<rspec-rails>, [">= 0", "= 1.2.4"])
+    s.add_dependency(%q<mocha>, [">= 0", "= 0.9.5"])
+  end
+end

data/spec/controllers/sorting_controller_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class SortableElementForNestedSet::SortingController < ActionController::Base
+  handles_sorting_of_nested_set
+  
+  def move
+    # This action is defined to let the specs set up the state of the controller easily
+    render :nothing => true
+  end
+end
+
+describe SortableElementForNestedSet::SortingController do
+  before do 
+    @moved_id = "1234"
+    @tree = ["sort", "order", "array"]
+    
+    xhr :post, :move, :moved_element_id => @moved_id, :tree_param => @tree
+  end
+    
+  describe "position_of" do 
+    it "should save the value of the given param in instance variable" do 
+      @controller.instance_eval  { position_of(:moved_element_id) }
+      @controller.dragged_record_id.should == @moved_id.to_i
+    end
+    
+    it "should return the controller instance" do 
+      result = @controller.instance_eval { position_of(:moved_element_id) }
+      result.should == @controller
+    end
+  end
+  
+  describe "in_tree" do 
+    before do 
+      @calculator_class = SortableElementForNestedSet::TreeMoveCalculator
+    
+      @placement_hash = {:new => "placement"}
+        
+      @calc_mock = mock
+      
+      @calc_mock.stubs(:placement_of).returns(@placement_hash)
+      @calculator_class.stubs(:new).returns(@calc_mock)
+    end
+    
+    it "should create TreeMoveCalculator" do
+      @calculator_class.expects(:new).with(@tree).returns(@calc_mock)
+      @controller.instance_eval{ in_tree(:tree_param) }
+    end
+    
+    it "should ask TreeMoveCalculator for the new placement" do
+      @controller.expects(:dragged_record_id).returns(321)
+      @calc_mock.expects(:placement_of).with(321)
+      
+      @controller.instance_eval{ in_tree(:tree_param) }
+    end
+    
+    it "should return hash with the position of the moved item" do 
+      result = @controller.instance_eval{ in_tree(:tree_param) }
+      result.should == @placement_hash
+    end
+  end
+end

data/spec/helpers/sortable_element_for_nested_set_helper_spec.rb

@@ -0,0 +1,114 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe SortableElementForNestedSetHelper do 
+  
+  # Shorten the class name a bit for the specs
+  OptsGenerator = SortableElementForNestedSetHelper::OptsGenerator 
+  
+  describe "sortable_element_reporting_target OptsGenerator" do 
+    before do 
+      @element_id = "el_name"
+      @param_name = "param_name"
+      @generator = OptsGenerator.new(@element_id, @param_name)
+    end
+    
+    it "should require two non-blank init args" do 
+      lambda {OptsGenerator.new()}.should raise_error
+      lambda {OptsGenerator.new("", "val")}.should raise_error
+      lambda {OptsGenerator.new("val", "")}.should raise_error
+      lambda {OptsGenerator.new("val", "val")}.should_not raise_error
+    end
+    
+    it "should create hash of options" do 
+      @generator.opts.should == {:with => @generator.with_value, :onChange => @generator.on_change_value }
+    end
+    
+    it "should create javascript for 'onChange' attribute" do 
+      @generator.on_change_value.should ==
+        "function(e) { $('#{@element_id}').moved_element = e.id; }"
+    end
+    
+    it "should create javascript for 'with' attribute" do 
+      @generator.with_value.should == 
+      "'#{@param_name}='+ $(#{@element_id.to_json}).moved_element.split('_').last() + '&' + Sortable.serialize(#{@element_id.to_json})"
+    end
+    
+  end
+  
+  describe "sortable_element_reporting_target" do 
+    it "should forward args to sortable_element_reporting_target_js " do 
+      helper.expects(:sortable_element_reporting_target_js).with("arg1", "arg2", "arg3")
+      helper.sortable_element_reporting_target("arg1", "arg2", "arg3")
+    end
+    
+    it "should wrap the javascript with the javascript_tag helper" do 
+      helper.stubs(:sortable_element_reporting_target_js).returns("raw_javascript")
+      helper.expects(:javascript_tag).with("raw_javascript").returns("result")
+      
+      helper.sortable_element_reporting_target("arg1", "arg1").should == "result"
+    end
+    
+  end
+  
+  describe "sortable_element_reporting_target_js" do 
+    
+    before do 
+      @opts_generator = mock("OptsGenerator") do 
+        stubs(:opts).returns({:hash => "of", :generated => "options"})
+      end
+      
+      OptsGenerator.stubs(:new).returns(@opts_generator)
+      helper.stubs(:sortable_element_js).returns("result")
+    end
+    
+    describe "argument validation" do 
+      after do 
+        @illegal_call.should raise_error
+      end
+      
+      it "should not allow the 'onChange' attribute" do 
+        @illegal_call = lambda do 
+          helper.sortable_element_reporting_target_js("element_id", "targetparam", :onChange => "causes failure" ) 
+        end
+      end
+      
+      it "should not allow the 'with' attribute" do 
+        @illegal_call = lambda do 
+          helper.sortable_element_reporting_target_js("element_id", "targetparam", :with => "causes failure" ) 
+        end
+      end
+      
+      it "should require the target_param_name parameter" do 
+        @illegal_call = lambda do 
+          helper.sortable_element_reporting_target_js("element_id", "") 
+        end
+      end
+    end
+    
+    it "should not require an options hash" do 
+      legal_call = lambda do 
+        helper.sortable_element_reporting_target_js("element_id", "targetparam") 
+      end
+      legal_call.should_not raise_error 
+    end
+    
+    it "should use sortable_element_js helper" do 
+      helper.expects(:sortable_element_js).with("element_id", @opts_generator.opts ).returns("result")
+      helper.sortable_element_reporting_target_js("element_id", "targetparam").should == "result"
+    end
+    
+    it "should merge generated options into the options hash passed to sortable_element" do
+      opts_from_view = {:options => "from view"}
+      expected_opts = opts_from_view.merge(@opts_generator.opts)
+      
+      helper.expects(:sortable_element_js).with("element_id", expected_opts )
+                                             
+      helper.sortable_element_reporting_target_js("element_id", "targetparam", opts_from_view)
+    end
+    
+    it "should create OptsGenerator using element_id and target_param arguments" do 
+      OptsGenerator.expects(:new).with("my_element_id", "my_target_param").returns(@opts_generator)
+      helper.sortable_element_reporting_target_js("my_element_id", "my_target_param")
+    end
+  end
+end

data/spec/models/tree_move_calculator_spec.rb

@@ -0,0 +1,91 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SortableElementForNestedSet::TreeMoveCalculator do
+  before do 
+    @class_under_test = SortableElementForNestedSet::TreeMoveCalculator
+    
+    @sort_order = 
+      {  
+        "0" => {"id" => "100",
+                "0" => {"id" => "200"},
+                "1" => {"id" => "300", 
+                        "1" => {"id" => "500"},
+                        "0" => {"id" => "600"}
+                       },
+                "2" => {"id" => "400"}
+               },
+        "1" => {"id" => "700" }
+      }
+      
+    @calculator = @class_under_test.new(@sort_order)
+  end
+  
+  it "should return placement details in a hash" do 
+    target_id = 1
+    @calculator.expects(:parent_of).with(target_id).returns(11)
+    @calculator.expects(:left_of).with(target_id).returns(12)
+    @calculator.expects(:right_of).with(target_id).returns(13)
+    
+    @calculator.placement_of(target_id).should == {:parent => 11, 
+            :move_to_right_of => 12, :move_to_left_of => 13}
+  end
+  
+  it "should find right_of" do 
+    @calculator.right_of(100).should == 700
+    @calculator.right_of(200).should == 300
+    @calculator.right_of(300).should == 400
+    @calculator.right_of(400).should be_nil
+    @calculator.right_of(500).should be_nil
+    @calculator.right_of(600).should == 500
+    @calculator.right_of(700).should be_nil
+  end
+  
+  it "should find left_of" do 
+    @calculator.left_of(100).should be_nil
+    @calculator.left_of(200).should be_nil
+    @calculator.left_of(300).should == 200
+    @calculator.left_of(400).should == 300
+    @calculator.left_of(500).should == 600
+    @calculator.left_of(600).should be_nil
+    @calculator.left_of(700).should == 100
+  end
+  
+  it "should find parent" do 
+    @calculator.parent_of(100).should be_nil 
+    @calculator.parent_of(700).should be_nil
+    
+    @calculator.parent_of(200).should == 100
+    @calculator.parent_of(300).should == 100
+    @calculator.parent_of(400).should == 100
+    
+    @calculator.parent_of(500).should == 300
+    @calculator.parent_of(600).should == 300
+  end
+  
+  it "create tree nodes with parents" do 
+    result = @class_under_test.create_tree_nodes(@sort_order)
+    result.size.should == 2
+    
+    result.first.id.should == 100
+    result.first.children.collect {|x| [x.parent_id, x.id] }.should == [ [100,200], [100, 300], [100,400] ]
+    result.first.children.second.children.collect {|x| [x.parent_id, x.id] }.should == [[300,600], [300,500] ]
+    
+    result.last.id.should == 700
+  end
+  
+  describe "to_hash()" do 
+    it "should return empty hash if array is empty" do 
+        @class_under_test.to_hash([]).should == {}
+    end
+    
+    it "should convert flat array to hash" do 
+      array = ["3", "2", "1"]
+      expected_hash = { "0" => {"id" => "3"}, 
+                        "1" => {"id" => "2"}, 
+                        "2" => {"id" => "1"} 
+                      }
+      
+      @class_under_test.to_hash(array).should == expected_hash
+    end
+  end
+end

data/spec/railsenv/app/controllers/application_controller.rb

@@ -0,0 +1,10 @@
+# Filters added to this controller apply to all controllers in the application.
+# Likewise, all the methods added will be available for all controllers.
+
+class ApplicationController < ActionController::Base
+  helper :all # include all helpers, all the time
+  protect_from_forgery # See ActionController::RequestForgeryProtection for details
+
+  # Scrub sensitive parameters from your log
+  # filter_parameter_logging :password
+end

data/spec/railsenv/config/boot.rb

@@ -0,0 +1,110 @@
+# Don't change this file!
+# Configure your app in config/environment.rb and config/environments/*.rb
+
+RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
+
+module Rails
+  class << self
+    def boot!
+      unless booted?
+        preinitialize
+        pick_boot.run
+      end
+    end
+
+    def booted?
+      defined? Rails::Initializer
+    end
+
+    def pick_boot
+      (vendor_rails? ? VendorBoot : GemBoot).new
+    end
+
+    def vendor_rails?
+      File.exist?("#{RAILS_ROOT}/vendor/rails")
+    end
+
+    def preinitialize
+      load(preinitializer_path) if File.exist?(preinitializer_path)
+    end
+
+    def preinitializer_path
+      "#{RAILS_ROOT}/config/preinitializer.rb"
+    end
+  end
+
+  class Boot
+    def run
+      load_initializer
+      Rails::Initializer.run(:set_load_path)
+    end
+  end
+
+  class VendorBoot < Boot
+    def load_initializer
+      require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer"
+      Rails::Initializer.run(:install_gem_spec_stubs)
+      Rails::GemDependency.add_frozen_gem_path
+    end
+  end
+
+  class GemBoot < Boot
+    def load_initializer
+      self.class.load_rubygems
+      load_rails_gem
+      require 'initializer'
+    end
+
+    def load_rails_gem
+      if version = self.class.gem_version
+        gem 'rails', version
+      else
+        gem 'rails'
+      end
+    rescue Gem::LoadError => load_error
+      $stderr.puts %(Missing the Rails #{version} gem. Please `gem install -v=#{version} rails`, update your RAILS_GEM_VERSION setting in config/environment.rb for the Rails version you do have installed, or comment out RAILS_GEM_VERSION to use the latest version installed.)
+      exit 1
+    end
+
+    class << self
+      def rubygems_version
+        Gem::RubyGemsVersion rescue nil
+      end
+
+      def gem_version
+        if defined? RAILS_GEM_VERSION
+          RAILS_GEM_VERSION
+        elsif ENV.include?('RAILS_GEM_VERSION')
+          ENV['RAILS_GEM_VERSION']
+        else
+          parse_gem_version(read_environment_rb)
+        end
+      end
+
+      def load_rubygems
+        require 'rubygems'
+        min_version = '1.3.1'
+        unless rubygems_version >= min_version
+          $stderr.puts %Q(Rails requires RubyGems >= #{min_version} (you have #{rubygems_version}). Please `gem update --system` and try again.)
+          exit 1
+        end
+
+      rescue LoadError
+        $stderr.puts %Q(Rails requires RubyGems >= #{min_version}. Please install RubyGems and try again: http://rubygems.rubyforge.org)
+        exit 1
+      end
+
+      def parse_gem_version(text)
+        $1 if text =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/
+      end
+
+      private
+        def read_environment_rb
+          File.read("#{RAILS_ROOT}/config/environment.rb")
+        end
+    end
+  end
+end
+
+# All that for this:
+Rails.boot!

data/spec/railsenv/config/database.yml

@@ -0,0 +1,22 @@
+# SQLite version 3.x
+#   gem install sqlite3-ruby (not necessary on OS X Leopard)
+development:
+  adapter: sqlite3
+  database: db/development.sqlite3
+  pool: 5
+  timeout: 5000
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  adapter: sqlite3
+  database: db/test.sqlite3
+  pool: 5
+  timeout: 5000
+
+production:
+  adapter: sqlite3
+  database: db/production.sqlite3
+  pool: 5
+  timeout: 5000

data/spec/railsenv/config/environment.rb

@@ -0,0 +1,41 @@
+# Be sure to restart your server when you modify this file
+
+# Specifies gem version of Rails to use when vendor/rails is not present
+RAILS_GEM_VERSION = '2.3.2' unless defined? RAILS_GEM_VERSION
+
+# Bootstrap the Rails environment, frameworks, and default configuration
+require File.join(File.dirname(__FILE__), 'boot')
+
+Rails::Initializer.run do |config|
+  # Settings in config/environments/* take precedence over those specified here.
+  # Application configuration should go into files in config/initializers
+  # -- all .rb files in that directory are automatically loaded.
+
+  # Add additional load paths for your own custom dirs
+  # config.load_paths += %W( #{RAILS_ROOT}/extras )
+
+  # Specify gems that this application depends on and have them installed with rake gems:install
+  # config.gem "bj"
+  # config.gem "hpricot", :version => '0.6', :source => "http://code.whytheluckystiff.net"
+  # config.gem "sqlite3-ruby", :lib => "sqlite3"
+  # config.gem "aws-s3", :lib => "aws/s3"
+
+  # Only load the plugins named here, in the order given (default is alphabetical).
+  # :all can be used as a placeholder for all plugins not explicitly named
+  # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
+
+  # Skip frameworks you're not going to use. To use Rails without a database,
+  # you must remove the Active Record framework.
+  # config.frameworks -= [ :active_record, :active_resource, :action_mailer ]
+
+  # Activate observers that should always be running
+  # config.active_record.observers = :cacher, :garbage_collector, :forum_observer
+
+  # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
+  # Run "rake -D time" for a list of tasks for finding time zone names.
+  config.time_zone = 'UTC'
+
+  # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+  # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}')]
+  # config.i18n.default_locale = :de
+end

data/spec/railsenv/config/environments/development.rb

@@ -0,0 +1,17 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# In the development environment your application's code is reloaded on
+# every request.  This slows down response time but is perfect for development
+# since you don't have to restart the webserver when you make code changes.
+config.cache_classes = false
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_view.debug_rjs                         = true
+config.action_controller.perform_caching             = false
+
+# Don't care if the mailer can't send
+config.action_mailer.raise_delivery_errors = false

data/spec/railsenv/config/environments/production.rb

@@ -0,0 +1,28 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# The production environment is meant for finished, "live" apps.
+# Code is not reloaded between requests
+config.cache_classes = true
+
+# Full error reports are disabled and caching is turned on
+config.action_controller.consider_all_requests_local = false
+config.action_controller.perform_caching             = true
+config.action_view.cache_template_loading            = true
+
+# See everything in the log (default is :info)
+# config.log_level = :debug
+
+# Use a different logger for distributed setups
+# config.logger = SyslogLogger.new
+
+# Use a different cache store in production
+# config.cache_store = :mem_cache_store
+
+# Enable serving of images, stylesheets, and javascripts from an asset server
+# config.action_controller.asset_host = "http://assets.example.com"
+
+# Disable delivery errors, bad email addresses will be ignored
+# config.action_mailer.raise_delivery_errors = false
+
+# Enable threaded mode
+# config.threadsafe!

data/spec/railsenv/config/environments/test.rb

@@ -0,0 +1,28 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# The test environment is used exclusively to run your application's
+# test suite.  You never need to work with it otherwise.  Remember that
+# your test database is "scratch space" for the test suite and is wiped
+# and recreated between test runs.  Don't rely on the data there!
+config.cache_classes = true
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+config.action_view.cache_template_loading            = true
+
+# Disable request forgery protection in test environment
+config.action_controller.allow_forgery_protection    = false
+
+# Tell Action Mailer not to deliver emails to the real world.
+# The :test delivery method accumulates sent emails in the
+# ActionMailer::Base.deliveries array.
+config.action_mailer.delivery_method = :test
+
+# Use SQL instead of Active Record's schema dumper when creating the test database.
+# This is necessary if your schema can't be completely dumped by the schema dumper,
+# like if you have constraints or database-specific column types
+# config.active_record.schema_format = :sql

data/spec/railsenv/config/initializers/backtrace_silencers.rb

@@ -0,0 +1,7 @@
+# Be sure to restart your server when you modify this file.
+
+# You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
+# Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }
+
+# You can also remove all the silencers if you're trying do debug a problem that might steem from framework code.
+# Rails.backtrace_cleaner.remove_silencers!

data/spec/railsenv/config/initializers/inflections.rb

@@ -0,0 +1,10 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format 
+# (all these examples are active by default):
+# ActiveSupport::Inflector.inflections do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end

data/spec/railsenv/config/initializers/mime_types.rb

@@ -0,0 +1,5 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new mime types for use in respond_to blocks:
+# Mime::Type.register "text/richtext", :rtf
+# Mime::Type.register_alias "text/html", :iphone

data/spec/railsenv/config/initializers/new_rails_defaults.rb

@@ -0,0 +1,19 @@
+# Be sure to restart your server when you modify this file.
+
+# These settings change the behavior of Rails 2 apps and will be defaults
+# for Rails 3. You can remove this initializer when Rails 3 is released.
+
+if defined?(ActiveRecord)
+  # Include Active Record class name as root for JSON serialized output.
+  ActiveRecord::Base.include_root_in_json = true
+
+  # Store the full class name (including module namespace) in STI type column.
+  ActiveRecord::Base.store_full_sti_class = true
+end
+
+# Use ISO 8601 format for JSON serialized times and dates.
+ActiveSupport.use_standard_json_time_format = true
+
+# Don't escape HTML entities in JSON, leave that for the #json_escape helper.
+# if you're including raw json in an HTML page.
+ActiveSupport.escape_html_entities_in_json = false

data/spec/railsenv/config/initializers/session_store.rb

@@ -0,0 +1,15 @@
+# Be sure to restart your server when you modify this file.
+
+# Your secret key for verifying cookie session data integrity.
+# If you change this key, all old sessions will become invalid!
+# Make sure the secret is at least 30 characters and all random, 
+# no regular words or you'll be exposed to dictionary attacks.
+ActionController::Base.session = {
+  :key         => '_railsenv_session',
+  :secret      => '5eea0426c25c0db25fb5a2e355216ce600e4c09909abc217f25ed64311de6c1d49bd422e244d04e76dd00b020a8f8c535b10a353f0b0d697350ac22f8a487294'
+}
+
+# Use the database for sessions instead of the cookie-based default,
+# which shouldn't be used to store highly confidential information
+# (create the session table with "rake db:sessions:create")
+# ActionController::Base.session_store = :active_record_store

data/spec/railsenv/config/locales/en.yml

@@ -0,0 +1,5 @@
+# Sample localization file for English. Add more files in this directory for other locales.
+# See http://github.com/svenfuchs/rails-i18n/tree/master/rails%2Flocale for starting points.
+
+en:
+  hello: "Hello world"

data/spec/railsenv/config/routes.rb

@@ -0,0 +1,43 @@
+ActionController::Routing::Routes.draw do |map|
+  # The priority is based upon order of creation: first created -> highest priority.
+
+  # Sample of regular route:
+  #   map.connect 'products/:id', :controller => 'catalog', :action => 'view'
+  # Keep in mind you can assign values other than :controller and :action
+
+  # Sample of named route:
+  #   map.purchase 'products/:id/purchase', :controller => 'catalog', :action => 'purchase'
+  # This route can be invoked with purchase_url(:id => product.id)
+
+  # Sample resource route (maps HTTP verbs to controller actions automatically):
+  #   map.resources :products
+
+  # Sample resource route with options:
+  #   map.resources :products, :member => { :short => :get, :toggle => :post }, :collection => { :sold => :get }
+
+  # Sample resource route with sub-resources:
+  #   map.resources :products, :has_many => [ :comments, :sales ], :has_one => :seller
+  
+  # Sample resource route with more complex sub-resources
+  #   map.resources :products do |products|
+  #     products.resources :comments
+  #     products.resources :sales, :collection => { :recent => :get }
+  #   end
+
+  # Sample resource route within a namespace:
+  #   map.namespace :admin do |admin|
+  #     # Directs /admin/products/* to Admin::ProductsController (app/controllers/admin/products_controller.rb)
+  #     admin.resources :products
+  #   end
+
+  # You can have the root of your site routed with map.root -- just remember to delete public/index.html.
+  # map.root :controller => "welcome"
+
+  # See how all your routes lay out with "rake routes"
+
+  # Install the default routes as the lowest priority.
+  # Note: These default routes make all actions in every controller accessible via GET requests. You should
+  # consider removing the them or commenting them out if you're using named routes and resources.
+  map.connect ':controller/:action/:id'
+  map.connect ':controller/:action/:id.:format'
+end

data/spec/sortable_element_for_nested_set_spec.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/spec_helper'

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--colour
+--format progress
+--loadby mtime

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/railsenv/config/environment")
+require 'spec'
+require 'spec/rails'
+
+Spec::Runner.configure do |config|
+  config.use_transactional_fixtures = true
+  config.use_instantiated_fixtures  = false
+  config.mock_with :mocha
+end
+
+plugin_spec_dir = File.dirname(__FILE__)
+ActiveRecord::Base.logger = Logger.new(plugin_spec_dir + "/debug.log")
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/sortable_element_for_nested_set")
+require File.expand_path(File.dirname(__FILE__) + "/../lib/sortable_element_for_nested_set_helper")
+

data/tasks/sortable_element_for_nested_set_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :sortable_element_for_nested_set do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification 
+name: sortable_element_for_nested_set
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 3
+  version: 0.1.3
+platform: ruby
+authors: 
+- Robin Spainhour
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-29 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 4
+        version: 1.2.4
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec-rails
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 4
+        version: 1.2.4
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 5
+        version: 0.9.5
+  type: :development
+  version_requirements: *id003
+description: Rails plugin for using script.aculo.us sortable_element for trees backed by nested sets.
+email: robin@robinspainhour.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- tasks/sortable_element_for_nested_set_tasks.rake
+- lib/tree_calc.rb
+- lib/sortable_element_for_nested_set.rb
+- lib/sortable_element_for_nested_set_helper.rb
+- README.rdoc
+files: 
+- tasks/sortable_element_for_nested_set_tasks.rake
+- init.rb
+- lib/tree_calc.rb
+- lib/sortable_element_for_nested_set.rb
+- lib/sortable_element_for_nested_set_helper.rb
+- README.rdoc
+- Rakefile
+- spec/helpers/sortable_element_for_nested_set_helper_spec.rb
+- spec/railsenv/app/controllers/application_controller.rb
+- spec/railsenv/config/routes.rb
+- spec/railsenv/config/initializers/backtrace_silencers.rb
+- spec/railsenv/config/initializers/mime_types.rb
+- spec/railsenv/config/initializers/inflections.rb
+- spec/railsenv/config/initializers/session_store.rb
+- spec/railsenv/config/initializers/new_rails_defaults.rb
+- spec/railsenv/config/environment.rb
+- spec/railsenv/config/locales/en.yml
+- spec/railsenv/config/boot.rb
+- spec/railsenv/config/database.yml
+- spec/railsenv/config/environments/development.rb
+- spec/railsenv/config/environments/test.rb
+- spec/railsenv/config/environments/production.rb
+- spec/railsenv/db/test.sqlite3
+- spec/spec_helper.rb
+- spec/sortable_element_for_nested_set_spec.rb
+- spec/spec.opts
+- spec/controllers/sorting_controller_spec.rb
+- spec/models/tree_move_calculator_spec.rb
+- Manifest
+- sortable_element_for_nested_set.gemspec
+has_rdoc: true
+homepage: http://github.com/robinsp/sortable_element_for_nested_set
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Sortable_element_for_nested_set
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: sortable_element_for_nested_set
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 2
+summary: Rails plugin for using script.aculo.us sortable_element for trees backed by nested sets.
+test_files: []
+