activerecord-sortable 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d99827ae2d5921a9e848eac321ae02850a4f2a6f
+  data.tar.gz: b838570af229fa92372b6459666f4469f67e70ac
+SHA512:
+  metadata.gz: 0ac4f1819d8e111a271364995d75cd43d7fe2315cfc89140efd16fda08313ddb0f3a09e31741da779a81830c377c4c342e40422fafdb22ef54f4ce2891ce689d
+  data.tar.gz: 03d4aa1bd6843d6d2a9e2fadddefd570d3d74950072a56d8f041c872274eff3cf5c3acdd713298a7fbd340a69bccd7c35c5fcde08519cf8b61c5805b4cddda5d

data/README.rdoc

@@ -0,0 +1,3 @@
+= Sortable
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,33 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Sortable'
+  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
+
+Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each {|f| load f }
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+
+task :default => :spec

data/lib/activerecord/sortable.rb

@@ -0,0 +1,8 @@
+require 'activerecord/sortable/acts_as_sortable'
+
+require 'activerecord/sortable/rails' if defined?(::Rails)
+
+module ActiveRecord
+  module Sortable
+  end
+end

data/lib/activerecord/sortable/acts_as_sortable.rb

@@ -0,0 +1,40 @@
+require 'activerecord/sortable/acts_as_sortable/instance_methods'
+
+require 'active_support'
+
+module ActiveRecord
+  module Sortable
+    module ActsAsSortable
+      extend ::ActiveSupport::Concern
+
+      module ClassMethods
+        def acts_as_sortable(&block)
+          options = {
+            :relation => ->(instance) {instance.class},
+            :append => false,
+            :position_column => :position
+          }
+          block.call(options) if block_given?
+
+          cattr_accessor :sortable_relation, :instance_reader => false, :instance_writer => false
+          cattr_accessor :sortable_append, :instance_reader => true, :instance_writer => false
+          cattr_accessor :sortable_position_column, :instance_reader => true, :instance_writer => false
+
+          self.sortable_relation = options[:relation]
+          self.sortable_append = options[:append]
+          self.sortable_position_column = options[:position_column]
+
+          scope "ordered_by_#{self.sortable_position_column}_asc".to_sym, -> { order(self.sortable_position_column => :asc) }
+
+          before_create :sortable_set_default_position
+          after_destroy :sortable_shift_on_destroy
+
+          include ActiveRecord::Sortable::ActsAsSortable::InstanceMethods
+        end
+      end
+    end
+  end
+end
+
+require 'active_record'
+ActiveRecord::Base.send :include, ActiveRecord::Sortable::ActsAsSortable

data/lib/activerecord/sortable/acts_as_sortable/instance_methods.rb

@@ -0,0 +1,66 @@
+module ActiveRecord
+  module Sortable
+    module ActsAsSortable
+      module InstanceMethods
+
+        def move_to!(new_position)
+          new_position = Integer(new_position)
+
+          transaction do
+            if new_position > self.send(sortable_position_column)
+              sortable_relation
+                .where(["#{sortable_position_column} > ? AND #{sortable_position_column} <= ?", self.send(sortable_position_column), new_position])
+                .update_all sortable_updates_with_timestamps("#{sortable_position_column} = #{sortable_position_column} - 1")
+            else
+              sortable_relation
+                .where(["#{sortable_position_column} >= ? AND #{sortable_position_column} < ?", new_position, self.send(sortable_position_column)])
+                .update_all sortable_updates_with_timestamps("#{sortable_position_column} = #{sortable_position_column} + 1")
+            end
+
+            self.update_attribute(sortable_position_column, new_position)
+          end
+        end
+
+
+        private
+
+        def sortable_relation
+          self.class.sortable_relation.call(self)
+        end
+
+        def sortable_set_default_position
+          sortable_assign_default_position unless self.send(sortable_position_column).present?
+
+          true
+        end
+
+        def sortable_assign_default_position
+          if sortable_append
+            next_position = (max_position = sortable_relation.pluck(self.sortable_position_column).max).present? ? max_position + 1 : 0
+            self.send("#{sortable_position_column}=".to_sym, next_position)
+          else
+            sortable_relation.update_all sortable_updates_with_timestamps("#{sortable_position_column} = #{sortable_position_column} + 1")
+            self.send("#{sortable_position_column}=".to_sym, 0)
+          end
+        end
+
+        def sortable_updates_with_timestamps(base_query)
+          current_time = current_time_from_proper_timezone
+
+          query_items = [base_query]
+
+          update_values = timestamp_attributes_for_update_in_model.map do |attr|
+            query_items << "#{attr} = ?"
+            current_time
+          end
+          updates = [query_items.join(', ')] + update_values
+        end
+
+        def sortable_shift_on_destroy
+          sortable_relation.where(["#{sortable_position_column} > ?", self.send(sortable_position_column)]).update_all sortable_updates_with_timestamps("#{sortable_position_column} = #{sortable_position_column} - 1")
+          true
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/sortable/rails.rb

@@ -0,0 +1,8 @@
+module ActiveRecord
+  module Sortable
+    module Rails
+      class Engine < ::Rails::Engine
+      end
+    end
+  end
+end

data/lib/activerecord/sortable/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module Sortable
+    VERSION = "0.0.1"
+  end
+end

data/lib/assets/javascripts/sortable.js

@@ -0,0 +1,99 @@
+(function(window, $){
+  if(!$){throw new Error('jQuery required by Sortable')};
+
+
+  function PositionsUpdater(node, current_node, new_position, old_position) {
+    this.node = node;
+    this.current_node = current_node;
+    this.new_position = new_position;
+    this.old_position = old_position;
+  };
+
+  PositionsUpdater.prototype.update = function() {
+    var step = this.new_position > this.old_position ? -1 : 1;
+    var start_position = step === -1 ? this.old_position + 1 : this.new_position;
+    var stop_position = step === -1 ? this.new_position : this.old_position - 1;
+    var target, data_position;
+    var current_node_role = this.current_node.data('role');
+
+    $('*[data-position]', this.node)
+      .filter(function(){
+        var position = $(this).data('position');
+        var role = $(this).data('role');
+
+        return (current_node_role !== role) && position >= start_position && position <= stop_position;
+      })
+      .each(function(){
+        var target = $(this);
+
+        var data_position = target.data('position');
+        var new_position = data_position + step;
+
+        target.attr('data-position', new_position).data('position', new_position);
+      });
+  };
+
+
+  function ServerSorter(node, current_node, new_position, positions_updater) {
+    this.node = node;
+    this.current_node = current_node;
+    this.new_position = new_position;
+    this.positions_updater = positions_updater;
+  };
+
+  ServerSorter.prototype.sort = function() {
+    $.ajax({
+      type: 'POST',
+      dataType: 'script',
+      url: this.current_node.data('move-url'),
+      data: {
+        position: this.new_position
+      },
+      success: $.proxy(this.sort_by_server_success, this),
+      error: $.proxy(this.sort_by_server_error, this)
+    });
+  };
+
+  ServerSorter.prototype.sort_by_server_success = function() {
+    this.positions_updater.update();
+    this.node.trigger('sortable:sort_success').trigger('sortable:stop').sortable('enable');
+  };
+
+  ServerSorter.prototype.sort_by_server_error = function() {
+    this.node.sortable('cancel').trigger('sortable:sort_error').trigger('sortable:stop').sortable('enable');
+  };
+
+
+  function Sortable(node) {
+    this.node = node;
+
+    this.node.sortable({
+      axis: 'y',
+      update: $.proxy(this.sortable_stop_handler, this)
+    });
+  };
+
+  Sortable.prototype.sortable_stop_handler = function(e, ui) {
+    this.node.sortable('disable').trigger('sortable:start');
+
+    var node = ui.item;
+    var new_position = node.index();
+    var old_position = parseInt(node.data('position'));
+
+    var positions_updater = new PositionsUpdater(this.node, node, new_position, old_position);
+
+    server_sorter = new ServerSorter(this.node, node, new_position, positions_updater);
+    server_sorter.sort();
+  };
+
+
+  $.fn.activerecord_sortable = function() {
+    var target = $(this);
+    target.each(function(){
+      var self = $(this);
+      var sortable_instance = new Sortable(self);
+
+      self.data('sortable-instance', sortable_instance);
+    });
+  }
+})(window, window.jQuery);

data/lib/tasks/sortable_tasks.rake

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

data/spec/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,9 @@
+//= require jquery
+//= require jquery_ujs
+//= require sortable
+
+//= require jquery.ui.sortable
+
+$(document).ready(function(){
+  $('*[data-role=activerecord_sortable]').activerecord_sortable();
+});

data/spec/dummy/app/assets/javascripts/jquery.simulate.js

@@ -0,0 +1,312 @@
+ /*!
+ * jQuery Simulate v@VERSION - simulate browser mouse and keyboard events
+ * https://github.com/jquery/jquery-simulate
+ *
+ * Copyright 2012 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * Date: @DATE
+ */
+
+;(function( $, undefined ) {
+
+var rkeyEvent = /^key/,
+  rmouseEvent = /^(?:mouse|contextmenu)|click/;
+
+$.fn.simulate = function( type, options ) {
+  return this.each(function() {
+    new $.simulate( this, type, options );
+  });
+};
+
+$.simulate = function( elem, type, options ) {
+  var method = $.camelCase( "simulate-" + type );
+
+  this.target = elem;
+  this.options = options;
+
+  if ( this[ method ] ) {
+    this[ method ]();
+  } else {
+    this.simulateEvent( elem, type, options );
+  }
+};
+
+$.extend( $.simulate, {
+
+  keyCode: {
+    BACKSPACE: 8,
+    COMMA: 188,
+    DELETE: 46,
+    DOWN: 40,
+    END: 35,
+    ENTER: 13,
+    ESCAPE: 27,
+    HOME: 36,
+    LEFT: 37,
+    NUMPAD_ADD: 107,
+    NUMPAD_DECIMAL: 110,
+    NUMPAD_DIVIDE: 111,
+    NUMPAD_ENTER: 108,
+    NUMPAD_MULTIPLY: 106,
+    NUMPAD_SUBTRACT: 109,
+    PAGE_DOWN: 34,
+    PAGE_UP: 33,
+    PERIOD: 190,
+    RIGHT: 39,
+    SPACE: 32,
+    TAB: 9,
+    UP: 38
+  },
+
+  buttonCode: {
+    LEFT: 0,
+    MIDDLE: 1,
+    RIGHT: 2
+  }
+});
+
+$.extend( $.simulate.prototype, {
+
+  simulateEvent: function( elem, type, options ) {
+    var event = this.createEvent( type, options );
+    this.dispatchEvent( elem, type, event, options );
+  },
+
+  createEvent: function( type, options ) {
+    if ( rkeyEvent.test( type ) ) {
+      return this.keyEvent( type, options );
+    }
+
+    if ( rmouseEvent.test( type ) ) {
+      return this.mouseEvent( type, options );
+    }
+  },
+
+  mouseEvent: function( type, options ) {
+    var event, eventDoc, doc, body;
+    options = $.extend({
+      bubbles: true,
+      cancelable: (type !== "mousemove"),
+      view: window,
+      detail: 0,
+      screenX: 0,
+      screenY: 0,
+      clientX: 1,
+      clientY: 1,
+      ctrlKey: false,
+      altKey: false,
+      shiftKey: false,
+      metaKey: false,
+      button: 0,
+      relatedTarget: undefined
+    }, options );
+
+    if ( document.createEvent ) {
+      event = document.createEvent( "MouseEvents" );
+      event.initMouseEvent( type, options.bubbles, options.cancelable,
+        options.view, options.detail,
+        options.screenX, options.screenY, options.clientX, options.clientY,
+        options.ctrlKey, options.altKey, options.shiftKey, options.metaKey,
+        options.button, options.relatedTarget || document.body.parentNode );
+
+      // IE 9+ creates events with pageX and pageY set to 0.
+      // Trying to modify the properties throws an error,
+      // so we define getters to return the correct values.
+      if ( event.pageX === 0 && event.pageY === 0 && Object.defineProperty ) {
+        eventDoc = event.relatedTarget.ownerDocument || document;
+        doc = eventDoc.documentElement;
+        body = eventDoc.body;
+
+        Object.defineProperty( event, "pageX", {
+          get: function() {
+            return options.clientX +
+              ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) -
+              ( doc && doc.clientLeft || body && body.clientLeft || 0 );
+          }
+        });
+        Object.defineProperty( event, "pageY", {
+          get: function() {
+            return options.clientY +
+              ( doc && doc.scrollTop || body && body.scrollTop || 0 ) -
+              ( doc && doc.clientTop || body && body.clientTop || 0 );
+          }
+        });
+      }
+    } else if ( document.createEventObject ) {
+      event = document.createEventObject();
+      $.extend( event, options );
+      // standards event.button uses constants defined here: http://msdn.microsoft.com/en-us/library/ie/ff974877(v=vs.85).aspx
+      // old IE event.button uses constants defined here: http://msdn.microsoft.com/en-us/library/ie/ms533544(v=vs.85).aspx
+      // so we actually need to map the standard back to oldIE
+      event.button = {
+        0: 1,
+        1: 4,
+        2: 2
+      }[ event.button ] || event.button;
+    }
+
+    return event;
+  },
+
+  keyEvent: function( type, options ) {
+    var event;
+    options = $.extend({
+      bubbles: true,
+      cancelable: true,
+      view: window,
+      ctrlKey: false,
+      altKey: false,
+      shiftKey: false,
+      metaKey: false,
+      keyCode: 0,
+      charCode: undefined
+    }, options );
+
+    if ( document.createEvent ) {
+      try {
+        event = document.createEvent( "KeyEvents" );
+        event.initKeyEvent( type, options.bubbles, options.cancelable, options.view,
+          options.ctrlKey, options.altKey, options.shiftKey, options.metaKey,
+          options.keyCode, options.charCode );
+      // initKeyEvent throws an exception in WebKit
+      // see: http://stackoverflow.com/questions/6406784/initkeyevent-keypress-only-works-in-firefox-need-a-cross-browser-solution
+      // and also https://bugs.webkit.org/show_bug.cgi?id=13368
+      // fall back to a generic event until we decide to implement initKeyboardEvent
+      } catch( err ) {
+        event = document.createEvent( "Events" );
+        event.initEvent( type, options.bubbles, options.cancelable );
+        $.extend( event, {
+          view: options.view,
+          ctrlKey: options.ctrlKey,
+          altKey: options.altKey,
+          shiftKey: options.shiftKey,
+          metaKey: options.metaKey,
+          keyCode: options.keyCode,
+          charCode: options.charCode
+        });
+      }
+    } else if ( document.createEventObject ) {
+      event = document.createEventObject();
+      $.extend( event, options );
+    }
+
+    if ( !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() ) || (({}).toString.call( window.opera ) === "[object Opera]") ) {
+      event.keyCode = (options.charCode > 0) ? options.charCode : options.keyCode;
+      event.charCode = undefined;
+    }
+
+    return event;
+  },
+
+  dispatchEvent: function( elem, type, event ) {
+    if ( elem.dispatchEvent ) {
+      elem.dispatchEvent( event );
+    } else if ( elem.fireEvent ) {
+      elem.fireEvent( "on" + type, event );
+    }
+  },
+
+  simulateFocus: function() {
+    var focusinEvent,
+      triggered = false,
+      element = $( this.target );
+
+    function trigger() {
+      triggered = true;
+    }
+
+    element.bind( "focus", trigger );
+    element[ 0 ].focus();
+
+    if ( !triggered ) {
+      focusinEvent = $.Event( "focusin" );
+      focusinEvent.preventDefault();
+      element.trigger( focusinEvent );
+      element.triggerHandler( "focus" );
+    }
+    element.unbind( "focus", trigger );
+  },
+
+  simulateBlur: function() {
+    var focusoutEvent,
+      triggered = false,
+      element = $( this.target );
+
+    function trigger() {
+      triggered = true;
+    }
+
+    element.bind( "blur", trigger );
+    element[ 0 ].blur();
+
+    // blur events are async in IE
+    setTimeout(function() {
+      // IE won't let the blur occur if the window is inactive
+      if ( element[ 0 ].ownerDocument.activeElement === element[ 0 ] ) {
+        element[ 0 ].ownerDocument.body.focus();
+      }
+
+      // Firefox won't trigger events if the window is inactive
+      // IE doesn't trigger events if we had to manually focus the body
+      if ( !triggered ) {
+        focusoutEvent = $.Event( "focusout" );
+        focusoutEvent.preventDefault();
+        element.trigger( focusoutEvent );
+        element.triggerHandler( "blur" );
+      }
+      element.unbind( "blur", trigger );
+    }, 1 );
+  }
+});
+
+
+
+/** complex events **/
+
+function findCenter( elem ) {
+  var offset,
+    document = $( elem.ownerDocument );
+  elem = $( elem );
+  offset = elem.offset();
+
+  return {
+    x: offset.left + elem.outerWidth() / 2 - document.scrollLeft(),
+    y: offset.top + elem.outerHeight() / 2 - document.scrollTop()
+  };
+}
+
+$.extend( $.simulate.prototype, {
+  simulateDrag: function() {
+    var i = 0,
+      target = this.target,
+      options = this.options,
+      center = findCenter( target ),
+      x = Math.floor( center.x ),
+      y = Math.floor( center.y ),
+      dx = options.dx || 0,
+      dy = options.dy || 0,
+      moves = options.moves || 3,
+      coord = { clientX: x, clientY: y };
+
+    this.simulateEvent( target, "mousedown", coord );
+
+    for ( ; i < moves ; i++ ) {
+      x += dx / moves;
+      y += dy / moves;
+
+      coord = {
+        clientX: Math.round( x ),
+        clientY: Math.round( y )
+      };
+
+      this.simulateEvent( document, "mousemove", coord );
+    }
+
+    this.simulateEvent( target, "mouseup", coord );
+    this.simulateEvent( target, "click", coord );
+  }
+});
+
+})( jQuery );