active_record_florder 0.0.1

data/coverage/.resultset.json

@@ -0,0 +1,307 @@
+{
+  "RSpec": {
+    "coverage": {
+      "/Users/marek/Developer/activerecord-florder/lib/active_record_florder.rb": [
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        null,
+        null,
+        1,
+        1,
+        1,
+        0,
+        null,
+        null,
+        1,
+        1862,
+        null,
+        null,
+        1,
+        null,
+        null,
+        null,
+        1,
+        1628,
+        null,
+        null,
+        1,
+        330,
+        null,
+        null,
+        null,
+        null,
+        1
+      ],
+      "/Users/marek/Developer/activerecord-florder/lib/active_record_florder/error.rb": [
+        1,
+        1,
+        null
+      ],
+      "/Users/marek/Developer/activerecord-florder/lib/active_record_florder/configurable.rb": [
+        1,
+        1,
+        1,
+        1,
+        47,
+        null,
+        null,
+        1,
+        2050,
+        null,
+        null,
+        1,
+        2042,
+        null,
+        null,
+        1,
+        1866,
+        null,
+        null,
+        1,
+        352,
+        null,
+        null,
+        null,
+        1,
+        0,
+        null,
+        null,
+        1,
+        1909,
+        null,
+        null,
+        1,
+        1021,
+        null,
+        null,
+        1,
+        1857,
+        null,
+        null,
+        1,
+        265,
+        null,
+        null,
+        null
+      ],
+      "/Users/marek/Developer/activerecord-florder/lib/active_record_florder/base.rb": [
+        1,
+        null,
+        1,
+        null,
+        1,
+        1,
+        null,
+        1,
+        3,
+        3,
+        null,
+        246,
+        null,
+        null,
+        3,
+        934,
+        87,
+        null,
+        null,
+        3,
+        47,
+        47,
+        null,
+        null,
+        3,
+        8,
+        86,
+        null,
+        null,
+        null,
+        null,
+        1,
+        417,
+        null,
+        417,
+        415,
+        411,
+        null,
+        411,
+        null,
+        411,
+        243,
+        null,
+        168,
+        null,
+        null,
+        411,
+        null,
+        null,
+        1,
+        null,
+        1,
+        50,
+        null,
+        50,
+        32,
+        null,
+        18,
+        null,
+        null,
+        null,
+        1,
+        null,
+        1,
+        32,
+        32,
+        32,
+        null,
+        32,
+        4,
+        null,
+        null,
+        32,
+        0,
+        null,
+        null,
+        32,
+        32,
+        null,
+        null,
+        32,
+        0,
+        null,
+        null,
+        32,
+        null,
+        null,
+        1,
+        4,
+        null,
+        null,
+        1,
+        639,
+        89,
+        null,
+        null,
+        176,
+        null,
+        176,
+        null,
+        176,
+        null,
+        null,
+        1,
+        176,
+        null,
+        176,
+        null,
+        156,
+        null,
+        20,
+        null,
+        null,
+        null,
+        null,
+        1,
+        411,
+        411,
+        null,
+        411,
+        null,
+        null,
+        null,
+        null,
+        411,
+        null,
+        null,
+        1,
+        41,
+        46,
+        46,
+        46,
+        null,
+        null,
+        null,
+        1,
+        46,
+        null,
+        null,
+        1,
+        226,
+        null,
+        null,
+        null,
+        null,
+        226,
+        null,
+        null,
+        1,
+        226,
+        null,
+        null,
+        9,
+        null,
+        null,
+        null,
+        41,
+        null,
+        null,
+        156,
+        null,
+        null,
+        20,
+        null,
+        null,
+        0,
+        0,
+        null,
+        null,
+        null,
+        null,
+        1,
+        858,
+        null,
+        858,
+        781,
+        null,
+        77,
+        null,
+        null,
+        null,
+        null,
+        null,
+        1,
+        934,
+        87,
+        null,
+        null,
+        null
+      ],
+      "/Users/marek/Developer/activerecord-florder/lib/active_record_florder/models.rb": [
+        1,
+        1,
+        1,
+        3,
+        3,
+        3,
+        null,
+        3,
+        4,
+        null,
+        null,
+        3,
+        null,
+        null,
+        null
+      ],
+      "/Users/marek/Developer/activerecord-florder/lib/active_record_florder/version.rb": [
+        1,
+        1,
+        null
+      ]
+    },
+    "timestamp": 1452102822
+  }
+}

data/db/config.example.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: db/active-model-florder_test.sqlite3

data/db/config.travis.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: db/active-model-florder_test.sqlite3

data/db/migrate/20151230204642_create_owners.rb

@@ -0,0 +1,6 @@
+class CreateOwners < ActiveRecord::Migration
+  def change
+    create_table(:owners) do |t|
+    end
+  end
+end

data/db/migrate/20151230210451_create_movables.rb

@@ -0,0 +1,8 @@
+class CreateMovables < ActiveRecord::Migration
+  def change
+    create_table(:movables) do |t|
+      t.references :owner
+      t.float :position, default: 0
+    end
+  end
+end

data/db/migrate/20160103190528_add_position2_to_movables.rb

@@ -0,0 +1,5 @@
+class AddPosition2ToMovables < ActiveRecord::Migration
+  def change
+    add_column :movables, :position_2, :float, default: 0
+  end
+end

data/db/schema.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema.define(version: 20160103190528) do
+
+  create_table "movables", force: true do |t|
+    t.integer "owner_id"
+    t.float   "position",   default: 0.0
+    t.float   "position_2", default: 0.0
+  end
+
+  create_table "owners", force: true do |t|
+  end
+
+end

data/lib/active_record_florder/base.rb

@@ -0,0 +1,236 @@
+require 'active_support'
+
+module ActiveRecordFlorder
+
+  # Base model implements all required logic
+  # It's depend on ActiveRecordFlorder::Configurable attributes
+  module Base
+    extend ActiveSupport::Concern
+
+    included do
+
+      # Include configuration methods
+      extend ActiveRecordFlorder::Configurable::ClassMethods
+      include ActiveRecordFlorder::Configurable
+
+      # Set initial position new records
+      before_create -> { push(:highest) }
+
+      # Scope all positions solving
+      # @api public
+      scope :position_scope, lambda { |value|
+        return all unless position_scope_attr.present? && value.present?
+        where(position_scope_attr.to_sym => value)
+      }
+
+      # Public Class method for getting models in right order
+      # @api public
+      scope :ordered, lambda {
+        direction = florder_direction.to_sym == :desc ? 'DESC' : 'ASC'
+        order("#{position_attr_name} #{direction}")
+      }
+
+      # Generates optimal positions, do not affect order
+      # @api public
+      def self.reinit_positions
+        all.order("#{position_attr_name} ASC").each_with_index do |model, index|
+          model.update_attribute(position_attr_name.to_sym, (index + 1) * next_position_step)
+        end
+      end
+    end
+
+    # Move model to position
+    # @param position {Float}
+    # @returns self {ModelInstance}
+    # @api public
+    def move(position)
+      position.to_f
+
+      fail ActiveRecordFlorder::Error, 'Position param is required' unless position
+      fail ActiveRecordFlorder::Error, 'Position should be > 0' unless (normalized_position = normalize_position(position)) > 0
+      normalized_position = normalize_position(position)
+
+      ensure_position_solving(position, normalized_position)
+
+      if new_record?
+        self[position_attr_name.to_sym] = normalized_position
+      else
+        update_attribute(position_attr_name.to_sym, normalized_position)
+      end
+
+      self
+    end
+
+    protected
+
+    # Increase/decrease models position but do not affect order
+    # @param direction [:increase, :decrease]
+    def slide(direction, ensured_position)
+      sibling = get_sibling(direction)
+
+      if sibling
+        slide_to_sibling(direction, sibling, ensured_position)
+      else
+        push(direction == :increase ? :highest : :lowest)
+      end
+    end
+
+    private
+
+    # Increase/decrease models position for cases where it should respect siblings
+    # @param direction [:increase, :desrease]
+    # @param sibling {Object}
+    # @param ensured_position {Float}
+    def slide_to_sibling(direction, sibling, ensured_position)
+      sibling_position = sibling.try(position_attr_name.to_sym)
+      position = send(position_attr_name.to_sym)
+      new_position = (position + sibling_position) / 2
+
+      if (new_position - ensured_position).abs < min_position_delta
+        new_position = get_slide_edge_position(direction, ensured_position)
+      end
+
+      unless (normalize_position(new_position) > 0)
+        return self.class.reinit_positions
+      end
+
+      min = new_position - min_position_delta
+      max = new_position + min_position_delta
+
+      self.class.position_scope(scope_value)
+        .where("#{position_attr_name} > ? AND #{position_attr_name} < ?", max, min).each do |conflict|
+          c.slide(direction)
+        end
+
+      move(new_position)
+    end
+
+    # Helper for getting value to SELECTconflict in one direction
+    # @param direction [:increase, :decrease]
+    # @param ensured_position {Float}
+    # @returns {Float}
+    def get_slide_edge_position(direction, ensured_position)
+      direction == :increase ? ensured_position + min_position_delta : ensured_position - min_position_delta
+    end
+
+    # Send model to end or begening
+    # @param place [:highest, :lowest]
+    def push(place)
+      unless self.class.position_scope(scope_value).any? { |m| m.position.present? }
+        return move(next_position_step)
+      end
+
+      sibling_position = get_sibling(place).try(position_attr_name.to_sym)
+
+      position = calc_push_position(place, sibling_position)
+
+      move(position)
+    end
+
+    # Calculate Edge (highest or lowest) positions based on current position of edge record
+    # @param place [:highest, :lowest]
+    # @param sibling_position {Float}
+    def calc_push_position(place, sibling_position)
+      return unless sibling_position
+
+      case place
+      when :highest
+        sibling_position + next_position_step
+      when :lowest
+        sibling_position / 2.0
+      end
+    end
+
+    # Find all models with conflicting position and solve conflicts
+    # @param position {Float}
+    # @param normalized_position {Float}
+    def ensure_position_solving(position, normalized_position)
+      min = normalized_position - min_position_delta
+      max = normalized_position + min_position_delta
+
+      conflicts = self.class.position_scope(scope_value)
+                  .where("#{position_attr_name} > ? AND #{position_attr_name} < ?", min, max)
+                  .where.not(id: id)
+                  .order(:position)
+
+      position_conflict_solver(conflicts, position, normalized_position) if conflicts.present?
+    end
+
+    # Resolve all given conflicts
+    # @param conflicts {Array}
+    # @param position {Float}
+    # @param normalized_position {Float}
+    def position_conflict_solver(conflicts, position, normalized_position)
+      conflicts.each do |conflict|
+        conflict_position = conflict.send(position_attr_name.to_sym)
+        direction = get_conflict_direction(position, conflict_position)
+        conflict.slide(direction, normalized_position)
+      end
+    end
+
+    # Helper condition for deciding conflict solving direction
+    # @param position {Float}
+    # @param conflict_position {Float}
+    # @returns Symbol [:increase, :decrease]
+    def get_conflict_direction(position, conflict_position)
+      conflict_position > position ? :increase : :decrease
+    end
+
+    # Sibblings getter for given vector
+    # @place [:increase, :decrease, :highest, :lowest]
+    # @returns Object
+    def get_sibling(vector)
+      conditions = get_siblings_conditions(vector)
+
+      self.class.position_scope(scope_value)
+        .where(conditions.first)
+        .order(conditions.last)
+        .limit(1).first
+    end
+
+    # get paramets for sibling SELECT
+    # @param vector [:increase, :decrease, :highest, :lowest]
+    # @returns Array
+    def get_siblings_conditions(vector)
+      case vector
+      when :increase
+        [["#{position_attr_name} > ?",
+          send(position_attr_name.to_sym)],
+         "#{position_attr_name} DESC"]
+      when :decrease
+        [["#{position_attr_name} < ?",
+          send(position_attr_name.to_sym)],
+         "#{position_attr_name} ASC"]
+      when :highest
+        [nil,
+         "#{position_attr_name} DESC"]
+      when :lowest
+        [nil,
+         "#{position_attr_name} ASC"]
+      else
+        error_message = "Place param '#{place}' is not one of: increase, decrease, highest, lowest."
+        fail ActiveRecordFlorder::Error, error_message
+      end
+    end
+
+    # returns normalized position (roundend value)
+    # @param position {Float}
+    # @returns Float
+    def normalize_position(position)
+      splitted_value = min_position_delta.to_s.split('.')
+
+      if splitted_value.size.to_i > 1
+        position.round(splitted_value.last.size)
+      else
+       (position / 10**(min_position_delta.to_s.size - 1)).round
+      end
+    end
+
+    # Scope helper
+    # returns value of scope attr
+    def scope_value
+      return unless position_scope_attr
+      send(position_scope_attr)
+    end
+  end
+end

data/lib/active_record_florder/configurable.rb

@@ -0,0 +1,52 @@
+module ActiveRecordFlorder
+
+  # Handle configuration loading and storing
+  # defines getters for configurable attributes
+  module Configurable
+
+    # Uses instance class variables
+    module ClassMethods
+      def florder_direction
+        @florder_config[:type]
+      end
+
+      def position_attr_name
+        @florder_config[:attribute] || ActiveRecordFlorder.get_attribute
+      end
+
+      def position_scope_attr
+        @florder_config[:scope] || ActiveRecordFlorder.get_scope
+      end
+
+      def min_position_delta
+        @florder_config[:min_delta] || ActiveRecordFlorder.get_min_delta
+      end
+
+      def next_position_step
+        @florder_config[:step] || ActiveRecordFlorder.get_step
+      end
+    end
+
+    # All instance methods are just proxy
+    # To Class Methods
+    def florder_direction
+      self.class.florder_direction
+    end
+
+    def position_attr_name
+      self.class.position_attr_name
+    end
+
+    def position_scope_attr
+      self.class.position_scope_attr
+    end
+
+    def min_position_delta
+      self.class.min_position_delta
+    end
+
+    def next_position_step
+      self.class.next_position_step
+    end
+  end
+end

data/lib/active_record_florder/error.rb

@@ -0,0 +1,4 @@
+module ActiveRecordFlorder
+  # Error class
+  class Error < StandardError; end
+end

data/lib/active_record_florder/models.rb

@@ -0,0 +1,28 @@
+module ActiveRecordFlorder
+
+  # Mixin for extending ActiveRecord::Base
+  # These methods are available in Models
+  module Models
+
+    # Initialize ActiveRecordFlorder with given options
+    # @param type [:asc, :desc], required!
+    # @param opts {Hash}, optional
+    def florder(type, opts = {})
+
+      # require type
+      fail ActiveRecordFlorder::Error, 'Define florder type :asc/:desc' unless [:asc, :desc].include?(type)
+
+      # setup configuration var
+      @florder_config = {}
+      @florder_config[:type] = type.to_sym
+
+      # add opts to config
+      opts.each do |key, value|
+        @florder_config[key.to_sym] = value
+      end
+
+      # include florder mixin
+      include ActiveRecordFlorder::Base
+    end
+  end
+end

data/lib/active_record_florder/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordFlorder
+  VERSION = "0.0.1".freeze
+end