in_order 0.1.0

data/Rakefile

@@ -0,0 +1,32 @@
+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    = 'InOrder'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/assets/config/in_order_manifest.js

@@ -0,0 +1,2 @@
+//= link_directory ../javascripts/in_order .js
+//= link_directory ../stylesheets/in_order .css

data/app/assets/javascripts/in_order/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file. JavaScript code in this file should be added after the last require_* statement.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require rails-ujs
+//= require activestorage
+//= require_tree .

data/app/assets/stylesheets/in_order/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/in_order/application_controller.rb

@@ -0,0 +1,5 @@
+module InOrder
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+  end
+end

data/app/controllers/in_order/concerns/response_helpers.rb

@@ -0,0 +1,33 @@
+
+module InOrder
+  module Concerns::ResponseHelpers
+    private
+
+    def respond_to_list(status=:ok, send_nothing_back=false)
+      respond_to do |format|
+        format.html { render partial_name }
+
+        format.js { render partial_name }
+
+        if send_nothing_back
+          #format.json { render nothing: true, status: status }
+          format.json { head status }
+        else
+          format.json do
+            #render json: (@elements ||= []), include: :subject, status: status
+            render json: (@elements ||= []), status: status
+          end
+        end
+      end
+    end
+
+    def http_status(status=:ok)
+      status ? status : :unprocessable_entity
+    end
+
+    def partial_name
+      params[:partial_name] or params[:partial] or 'index'
+    end
+  end
+end
+

data/app/controllers/in_order/elements_controller.rb

@@ -0,0 +1,47 @@
+
+module InOrder
+  class ElementsController < ::ApplicationController
+    include Concerns::ResponseHelpers
+
+    def create
+      marker_id, adjacency = element_params.values_at(:marker_id, :adjacency)
+
+      InOrder::Insert.call(record_key, marker_id, adjacency)
+
+      respond_to_list http_status(:created), true
+    end
+
+    def update
+      target = params[:id]
+
+      marker, adjacency = element_params.values_at(:marker_id, :adjacency)
+
+      InOrder::Move.new(target, marker, adjacency).call
+
+      respond_to_list
+    end
+
+    def destroy
+      target = params[:id]
+
+      InOrder::Remove.new(target).call
+
+      respond_to_list
+    end
+
+    private
+
+    def element_params
+      params.require(:element).permit(*element_names)
+    end
+
+    def element_names
+      %i(marker_id adjacency subject_type subject_id)
+    end
+
+    def record_key
+      element_params.values_at(:subject_type, :subject_id)
+    end
+  end
+end
+

data/app/controllers/in_order/lists_controller.rb

@@ -0,0 +1,86 @@
+
+module InOrder
+  class ListsController < ::ApplicationController
+    include Concerns::ResponseHelpers
+
+    def index
+      @elements = InOrder::Fetch.new(keys).elements
+
+      respond_to_list
+    end
+
+    def create
+      @elements = InOrder::Create.new(keys).(record_keys)
+
+      respond_to_list http_status(:created)
+    end
+
+    def destroy
+      if element = InOrder::Element.find_by_id(params[:id])
+        delete_by_keys element.to_keys
+      end
+
+      respond_to_list http_status(:accepted), true
+    end
+
+    def remove
+      delete_by_keys keys
+
+      respond_to_list http_status(:accepted), true
+    end
+
+    def add
+      update = InOrder::Update.new(keys)
+
+      @elements = update.(record_keys, append: append_to_existing_list?,
+                                       uniq: uniq?,
+                                       max: max)
+
+      respond_to_list http_status
+    end
+
+    private
+
+    def append_to_existing_list?
+      param = list_params[:position]
+
+      param.blank? or param =~ /(after|last)/i ? true : false
+    end
+
+    def max
+      list_params[:max]
+    end
+
+    FALSITIES = %w(f false 0 n no)
+    def uniq?
+      uniq = list_params[:uniq]
+
+      uniq != false and (uniq.blank? or FALSITIES.exclude?(uniq.strip))
+    end
+
+    def record_keys
+      list_params[:record_keys]
+    end
+
+    def list_params
+      params.fetch(:list).permit(*list_names)
+    end
+
+    def list_names
+      [ :scope, :owner_type, :owner_id, # keys for element list
+        :position, :max, # for add action
+        record_keys: [] ] # records to attach
+    end
+
+    def keys
+      owner = list_params.values_at :owner_type, :owner_id
+
+      InOrder::Aux::Keys.new(owner, list_params[:scope])
+    end
+
+    def delete_by_keys(deletion_keys)
+      InOrder::Element.delete_elements deletion_keys
+    end
+  end
+end
+

data/app/helpers/in_order/application_helper.rb

@@ -0,0 +1,4 @@
+module InOrder
+  module ApplicationHelper
+  end
+end

data/app/jobs/in_order/application_job.rb

@@ -0,0 +1,4 @@
+module InOrder
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/in_order/application_mailer.rb

@@ -0,0 +1,6 @@
+module InOrder
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/in_order/add.rb

@@ -0,0 +1,51 @@
+
+module InOrder
+  # Adds a new element at the beginning or end of a list.
+  # Identified (i.e. keyed) by an Owner and/or Scope.
+  class Add
+    include Aux::VarKeys
+    include Aux::CreateElement
+
+    # +model+ is an ActiveRecord model to be linked
+    def call(model, at: :bottom)
+      bottom?(at) ? append(model) : prepend(model)
+    end
+
+    def prepend(model)
+      insert model, :before, first_element
+    end
+    alias shift prepend
+
+    def append(model)
+      insert model, :after, last_element
+    end
+    alias push append
+
+    def insert(model, adjacency=nil, marker=nil)
+      marker = block_given? ? yield(iterator, model, adjacency, marker) : marker
+
+      InOrder::Element.transaction do
+        Insert.new(create_element(model, keys), marker, adjacency).call
+      end
+    end
+
+    private
+
+    def bottom?(at)
+      at.nil? or %i(bottom last end).include?(at.to_sym)
+    end
+
+    def first_element
+      InOrder::Element.first_element(keys)
+    end
+
+    def last_element
+      InOrder::Element.last_element(keys)
+    end
+
+    def iterator
+      Aux::ElementIterator.new(keys)
+    end
+  end
+end
+

data/app/models/in_order/application_record.rb

@@ -0,0 +1,5 @@
+module InOrder
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/in_order/aux/create_element.rb

@@ -0,0 +1,17 @@
+
+module InOrder
+  module Aux
+    module CreateElement
+      private
+
+      def create_element(subject, keys, element_id=nil)
+        poly_key = Aux::PolyKey.new(subject, name: :subject)
+
+        atts = keys.(poly_key.to_params.merge element_id: element_id)
+
+        InOrder::Element.create(atts)
+      end
+    end
+  end
+end
+

data/app/models/in_order/aux/element_iterator.rb

@@ -0,0 +1,39 @@
+
+module InOrder
+  module Aux
+    class ElementIterator
+      include Enumerable
+
+      include Comparable
+
+      include Aux::VarKeys
+
+      def initialize(*args)
+        super if args.any?
+      end
+
+      def each(current=get_first, &block)
+        if block
+          if current
+            yield current
+
+            each current.element, &block
+          end 
+        else
+          to_enum :each
+        end
+      end
+
+      def <=>(other)
+        subject <=> other.subject
+      end
+
+      private
+
+      def get_first
+        InOrder::Element.first_element(keys) if keys
+      end
+    end
+  end
+end
+

data/app/models/in_order/aux/get_element.rb

@@ -0,0 +1,17 @@
+
+module InOrder
+  module Aux
+    module GetElement
+      private
+
+      def get_element(element_candidate)
+        if InOrder::Element === element_candidate
+          element_candidate
+        elsif element_candidate
+          InOrder::Element.find(element_candidate)
+        end
+      end
+    end
+  end
+end
+

data/app/models/in_order/aux/get_keys.rb

@@ -0,0 +1,27 @@
+
+module InOrder
+  module Aux
+    module GetKeys
+      private
+
+      def get_keys(keys)
+        if keys&.any?
+          if keys_instance? keys[0]
+            keys[0]
+          elsif Array === keys[0] and keys_instance? keys[0][0]
+            keys[0][0]
+          else
+            InOrder::Aux::Keys.new(*keys)
+          end
+        end
+      end
+
+      private
+
+      def keys_instance?(candidate)
+        InOrder::Aux::Keys === candidate
+      end
+    end
+  end
+end
+

data/app/models/in_order/aux/keys.rb

@@ -0,0 +1,58 @@
+
+module InOrder
+  module Aux
+    class Keys
+      attr_accessor :scope, :owner
+
+      def initialize(_owner=nil, _scope=nil, owner: _owner, scope: _scope)
+        self.owner = owner
+
+        self.scope = scope
+      end
+
+      def call(**extras)
+        to_params.merge extras
+      end
+
+      def valid?
+        to_a.any?
+      end
+
+      def to_h
+        owner_params.merge scope_params
+      end
+      alias to_params to_h
+
+      def to_s
+        to_a.compact.map(&:to_s) * ', '
+      end
+
+      def to_a
+        [ owner, scope ]
+      end
+
+      def owner_params
+        owner_key.to_params
+      end
+
+      def scope_params
+        { scope: scope }
+      end
+
+      def owner_key
+        InOrder::Aux::PolyKey.new(owner, default_name: 'owner')
+      end
+
+      def ==(other)
+        to_a == other.to_a
+      end
+
+      private
+
+      def hash
+        to_a.hash
+      end
+    end
+  end
+end
+

data/app/models/in_order/aux/poly_find.rb

@@ -0,0 +1,24 @@
+
+module InOrder
+  module Aux
+    class PolyFind
+      attr_accessor :poly_key
+
+      def initialize(*args)
+        self.poly_key = args.first if InOrder::Aux::PolyKey === args.first
+
+        self.poly_key ||= PolyKey.new(*args)
+      end
+
+      def call
+        poly_key.type.constantize.find poly_key.id if poly_key.valid?
+      end
+
+      def self.call(keys)
+        (keys || []).map {|key| new(key).call }
+          .compact
+      end
+    end
+  end
+end
+

data/app/models/in_order/aux/poly_key.rb

@@ -0,0 +1,117 @@
+
+module InOrder
+  module Aux
+    class PolyKey
+      FIELD_NAMES = %i(type id)
+
+      SPLITTER_RE = %r([-,:/^\\|\s])
+
+      attr_accessor :type, :id, :default_name
+
+      def initialize(candidate, id=nil, name: nil, default_name: name)
+        self.default_name = default_name
+
+        candidate = [ candidate, id ] if id
+
+        assign candidate
+      end
+
+      def to_s(delim='-')
+        "#{type}#{delim}#{id}"
+      end
+      alias to_param to_s
+      alias to_key to_s
+
+      def to_a
+        [ type, id ]
+      end
+
+      def to_h(field_names=full_names)
+        field_names.zip(to_a).to_h
+      end
+      alias to_params to_h
+
+      def to_bare_params
+        to_h FIELD_NAMES
+      end
+      alias to_short_params to_bare_params
+
+      # REST key params
+      def to_id_key_params
+        { id: to_s }
+      end
+      def to_id_params
+        { id: id }
+      end
+      def to_type_params
+        { type: type }
+      end
+
+      def to_params_by_name(key_name=nil, default: true)
+        key_name ||= name_prefix
+
+        { key_name.to_sym => to_bare_params }
+      end
+      #alias to_named params to_params_by_name
+
+      def set(type=nil, _id=nil, id: _id)
+        self.type = type.to_s if type
+
+        self.id = id
+
+        self
+      end
+
+      def valid?
+        type.present? and id.present?
+      end
+
+      protected
+
+      def type_name
+        type.demodulize.underscore if type
+      end
+
+      def name_prefix
+        default_name or type_name
+      end
+
+      def full_name(suffix)
+        "#{name_prefix}_#{suffix}".to_sym
+      end
+
+      def full_names
+        return full_name(:type), full_name(:id)
+      end
+
+      private
+
+      def assign(key)
+        case key
+        when String
+          set(*key.split(SPLITTER_RE))
+        when Array
+          set(*key)
+        when Hash
+          try_to_set_from_hash(key)
+        when model?
+          set(key.class, key.to_param)
+        end
+      end
+
+      def model?
+        -> whatever { whatever.respond_to?(:to_model) }
+      end
+
+      def try_to_set_from_hash(key)
+        set_from_hash(key, FIELD_NAMES)
+
+        set_from_hash(key, full_names) if not valid? and name_prefix
+      end
+      def set_from_hash(key, name_args)
+        set(*key.values_at(*name_args))
+      end
+    end
+  end
+end
+

data/app/models/in_order/aux/position_base.rb

@@ -0,0 +1,25 @@
+
+module InOrder
+  module Aux
+    class PositionBase
+      include Aux::GetElement
+
+      attr_accessor :target, :marker, :adjacency
+
+      def initialize(target, marker, adjacency=nil)
+        self.target = get_element target
+
+        self.marker = get_element marker
+
+        self.adjacency = adjacency.present? ? adjacency.to_sym : :after
+      end
+
+      private
+
+      def after?
+        adjacency == :after
+      end
+    end
+  end
+end
+