activekit 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 630c8d871f28fedaf525eecbf06fdfb396bba0f62282ec3a8d7d9ef359a833c4
-  data.tar.gz: 154de328d7cc8e4520ff9f5f5f57ee6b1e73cf0df352d2aaee97387dca9a06a1
+  metadata.gz: c2d19ba43a09297c57c1b373864a53bf9b68787fe3a5b46a5167ae178db0800a
+  data.tar.gz: fee7a6d8f645787a847fd33a3500d0aade7162a8ff855c45349e45f77d4fe437
 SHA512:
-  metadata.gz: 68aaf23851ac2ba3ae9d73eb4474a3c7fe789c7e6f6e61c0d0e85d23a77f159c9e219cd635a28f99cc215f0b4605e43046196ebbf384f172e4ac0bd0f33fce95
-  data.tar.gz: 0753d639192b574bda48eee23df69d8f23e95d24c6c03f7571b4fb87c28a99a08bfd346a30b7ff0b0a271a890d4878e2cd37c7aa50bf912d0f21d29014e968f1
+  metadata.gz: 7b4e68fd3ee58d3c8d2d7a40995a12fcce17f8264548eb7a178422a009706741833c727f723cc8888d66409affbe77770c77eced0d75d1c1249ec9c335a54512
+  data.tar.gz: 0b551a885c6e90178aa7711d8c6356b448a57a28d319ce3daf230e93b2c5d92bd3a2a10f70489ee0cd5f9f77f2490cd6962c33426a089d25dc209d4d9f6d73a5

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2023 plainsource
+Copyright 2023 Timeboard
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -2,7 +2,46 @@
 Add the essential kit for rails ActiveRecord models and be happy.
 
 ## Usage
-How to use my plugin.
+
+### Position Attribute
+
+Add positioning to your ActiveRecord models.
+Position Attribute provides full positioning functionality using lexicographic ordering for your model database records.
+
+You can also add multiple position attributes in one model to store different arrangements.
+
+Just create a database column in your model with type :string with index.
+```ruby
+add_column :products, :arrangement, :string, index: true, before: :created_at
+```
+
+Then define the column name in your model like below.
+```ruby
+class Product < ApplicationRecord
+  position_attribute :arrangement
+end
+```
+
+Creating the record will automatically set it to the last position:
+```ruby
+product = Product.create(name: "Nice Product")
+```
+
+The following attribute methods will be added to your model object to use:
+```ruby
+product.arrangement_position = 1 # Set the position
+product.arrangement_position # Access the manually set position
+product.arrangement_position_in_database # Check the position as per database
+product.arrangement_position_options # Can be used in dropdown
+product.arrangement_position_maximum # Check current maximum position
+```
+
+The following class methods will be added to your model class to use:
+```ruby
+# If a database table already has existing rows, run this to set initial values.
+# You can also run this to manually harmonize a position attribute column.
+Product.harmonize_arrangement!
+```
 
 ## Installation
 Add this line to your application's Gemfile:

data/lib/active_kit/engine.rb

@@ -4,16 +4,16 @@ module ActiveKit
     config.eager_load_namespaces << ActiveKit
 
     initializer "active_kit.add_middleware" do |app|
-      require "active_kit/base/middleware"
+      require "active_kit/position/middleware"
 
-      app.middleware.use ActiveKit::Base::Middleware
+      app.middleware.use ActiveKit::Position::Middleware
     end
 
-    initializer "active_kit.activekitable" do
-      require "active_kit/base/activekitable"
+    initializer "active_kit.position" do
+      require "active_kit/position/positionable"
 
       ActiveSupport.on_load(:active_record) do
-        include ActiveKit::Base::Activekitable
+        include ActiveKit::Position::Positionable
       end
     end
   end

data/lib/active_kit/position/harmonize.rb

@@ -0,0 +1,71 @@
+module ActiveKit
+  module Position
+    class Harmonize
+      def initialize(current_class:, name:, scope:)
+        @current_class = current_class
+        @name = name
+
+        @scoped_class = @current_class.where(scope)
+        @positioning = Positioning.new
+        @batch_size = 1000
+      end
+
+      def run!
+        @current_class.transaction do
+          chair_at_params, scoped_class_with_order, chair_method, offset_operator = control
+          currvalue = @positioning.chair_at(**chair_at_params, increase_spot_length_by: 1).first
+
+          first_run = true
+          where_offset = nil
+          loop do
+            records = scoped_class_with_order.where(where_offset).limit(@batch_size)
+            break if records.empty?
+
+            records.lock.each do |record|
+              value, reharmonize = first_run ? [currvalue, false] : @positioning.public_send(chair_method, currvalue: currvalue)
+              raise message_for_reharmonize if reharmonize
+
+              record.send("#{@name}=", value)
+              record.save!
+
+              currvalue = record.public_send("#{@name}")
+              first_run = false
+            end
+
+            where_offset = ["#{@name} #{offset_operator} ?", currvalue]
+          end
+        end
+
+        Rails.logger.info "ActiveKit::Position | Harmonize for :#{@name}: completed."
+      end
+
+      private
+
+      def control
+        records = @scoped_class.where.not("#{@name}": nil).order("#{@name}": :asc, id: :asc).select(@name.to_sym)
+        headtier = records.first&.try(@name.to_sym)&.split("|")&.first&.last&.to_i # returns a tire integer
+        foottier = records.last&.try(@name.to_sym)&.split("|")&.first&.last&.to_i # returns a tire integer
+
+        if headtier == foottier
+          nexttier, ordering = (headtier == 0) ? [1, :foot_to_head] : [0, :head_to_foot]
+        else
+          maxitier = (headtier.nil? || foottier.nil?) ? (headtier.nil? ? foottier : headtier) : (headtier > foottier ? headtier : foottier)
+          nexttier, ordering = (maxitier + 1), :foot_to_head
+        end
+        scoped_order, chair_method, offset_operator = (ordering == :head_to_foot) ? [:asc, :chair_below, ">"] : [:desc, :chair_above, "<"]
+
+        scoped_class_with_order = @scoped_class.order("#{@name}": scoped_order, id: scoped_order)
+        scoped_class_with_order_count = scoped_class_with_order.count
+        initial_position = (ordering == :head_to_foot) ? 1 : scoped_class_with_order_count
+
+        chair_at_params = { position: initial_position, tier_no: nexttier, total_count: scoped_class_with_order_count }
+
+        [chair_at_params, scoped_class_with_order, chair_method, offset_operator]
+      end
+
+      def message_for_reharmonize
+        "Harmonize cannot ask to harmonize again. Please check values of attribute '#{@name}' and try again."
+      end
+    end
+  end
+end

data/lib/active_kit/{base → position}/middleware.rb

@@ -1,22 +1,23 @@
 module ActiveKit
-  module Base
+  module Position
     class Middleware
       def initialize(app)
         @app = app
       end
 
-      # Middleware that determines which ActiveKit middlewares to run.
       def call(env)
         request = ActionDispatch::Request.new(env)
 
-        activekit_run(request) do
+        middleware_run(request) do
           @app.call(env)
         end
       end
 
       private
 
-      def activekit_run(request, &blk)
+      def middleware_run(request, &blk)
+        # Position middleware code
+
         yield
       end
     end

data/lib/active_kit/position/positionable.rb

@@ -0,0 +1,77 @@
+require 'active_support/concern'
+
+module ActiveKit
+  module Position
+    module Positionable
+      extend ActiveSupport::Concern
+
+      included do
+      end
+
+      class_methods do
+        def position_attribute(name, **options)
+          scope = options[:scope] || {}
+
+          attribute "#{name}_position", :integer
+
+          validates "#{name}", presence: true, uniqueness: { conditions: -> { where(scope) }, case_sensitive: false, allow_blank: true }, length: { maximum: 255, allow_blank: true }
+          validates "#{name}_position", numericality: { only_integer: true, greater_than_or_equal_to: 1, less_than_or_equal_to: lambda { |record| record.public_send("#{name}_position_maximum") + 1 }, allow_blank: true }
+
+          before_validation "#{name}_reposition".to_sym
+          after_commit "#{name}_reharmonize".to_sym
+
+          class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def #{name}_position_in_database
+              self.#{name}_positioner.position_in_database
+            end
+
+            def #{name}_position_options
+              self.#{name}_positioner.position_options
+            end
+
+            def #{name}_position_maximum
+              self.#{name}_positioner.position_maximum
+            end
+
+            def self.harmonize_#{name}!
+              ActiveKit::Position::Harmonize.new(current_class: self, name: '#{name}', scope: #{scope}).run!
+            end
+
+            private
+
+            def #{name}=(value)
+              super(value)
+            end
+
+            def #{name}_positioner
+              @#{name}_positioner ||= ActiveKit::Position::Positioner.new(record: self, name: '#{name}', scope: #{scope})
+            end
+
+            def #{name}_reposition
+              return unless (self.#{name}.blank? && self.#{name}_position.blank?) || self.#{name}_position.present?
+
+              position_maximum_cached = self.#{name}_positioner.position_maximum
+
+              if self.#{name}.blank? && self.#{name}_position.blank?
+                self.#{name}_position = position_maximum_cached + 1
+              end
+
+              if self.#{name}_position.present? && self.#{name}_position >= 1 && self.#{name}_position <= (position_maximum_cached + 1)
+                if self.#{name}_position != #{name}_position_in_database
+                  self.#{name} = self.#{name}_positioner.spot_for(position: self.#{name}_position, position_maximum_cached: position_maximum_cached)
+                end
+              end
+            end
+
+            def #{name}_reharmonize
+              return unless self.#{name}_positioner.reharmonize?
+
+              self.class.harmonize_#{name}!
+              self.#{name}_positioner.reharmonized!
+            end
+          CODE
+        end
+      end
+    end
+  end
+end

data/lib/active_kit/position/positioner.rb

@@ -0,0 +1,87 @@
+module ActiveKit
+  module Position
+    class Positioner
+      def initialize(record:, name:, scope:)
+        @record = record
+        @name = name
+
+        @scoped_class = @record.class.where(scope).order("#{@name}": :asc)
+        @reharmonize = false
+        @positioning = Positioning.new
+      end
+
+      def position_in_database
+        @scoped_class.where("#{@name}": ..@record.public_send("#{@name}_in_database")).count if @record.public_send("#{@name}_in_database")
+      end
+
+      def position_options
+        (1..position_maximum).map { |position| [position, "Position #{position}"] }
+      end
+
+      def position_maximum
+        value = self.maxivalue
+        value ? @scoped_class.where("#{@name}": ..value).count : 0
+      end
+
+      def spot_for(position:, position_maximum_cached:)
+        raise "position or position_maximum_cached cannot be empty for spot_for in activekit." unless position && position_maximum_cached
+
+        edge_position = position_maximum_cached + 1
+        if position == edge_position && position == 1
+          value, @reharmonize = @positioning.chair_first
+        elsif position == edge_position
+          value, @reharmonize = @positioning.chair_below(currvalue: self.maxivalue)
+        elsif position_in_database.nil?
+          value, @reharmonize = @positioning.stool_above(currvalue: currvalue(position, position_maximum_cached),
+                                                             prevvalue: prevvalue(position, position_maximum_cached))
+        elsif position > position_in_database
+          value, @reharmonize = @positioning.stool_below(currvalue: currvalue(position, position_maximum_cached),
+                                                             nextvalue: nextvalue(position, position_maximum_cached))
+        else
+          value, @reharmonize = @positioning.stool_above(currvalue: currvalue(position, position_maximum_cached),
+                                                             prevvalue: prevvalue(position, position_maximum_cached))
+        end
+
+        value
+      end
+
+      def reharmonize?
+        @reharmonize
+      end
+
+      def reharmonized!
+        @reharmonize = false
+      end
+
+      private
+
+      def maxivalue
+        @scoped_class.last&.public_send(@name)
+      end
+
+      def prevvalue(position, position_maximum_cached)
+        prevvalue?(position, position_maximum_cached) ? @scoped_class.offset(position - 2).first.public_send(@name) : nil
+      end
+
+      def currvalue(position, position_maximum_cached)
+        currvalue?(position, position_maximum_cached) ? @scoped_class.offset(position - 1).first.public_send(@name) : nil
+      end
+
+      def nextvalue(position, position_maximum_cached)
+        nextvalue?(position, position_maximum_cached) ? @scoped_class.offset(position - 0).first.public_send(@name) : nil
+      end
+
+      def prevvalue?(position, position_maximum_cached)
+        position > 1
+      end
+
+      def currvalue?(position, position_maximum_cached)
+        position >= 1 && position <= position_maximum_cached
+      end
+
+      def nextvalue?(position, position_maximum_cached)
+        position < position_maximum_cached
+      end
+    end
+  end
+end

data/lib/active_kit/position/positioning.rb

@@ -0,0 +1,86 @@
+module ActiveKit
+  module Position
+    class Positioning
+      BASE = 36
+
+      def initialize
+        @initial_tier = "t0"
+        @initial_spot = "00"
+        @initial_slot = "hz"
+      end
+
+      def chair_first
+        chair(@initial_tier, @initial_spot, @initial_slot)
+      end
+
+      def chair_at(position:, tier_no:, total_count:, increase_spot_length_by:)
+        nicetire = "t#{tier_no}"
+        nicespot = (position - 1).to_s(BASE)
+        nicespot = nicespot.rjust((total_count - 1).to_s(BASE).length + increase_spot_length_by, "0")
+        chair(nicetire, nicespot, @initial_slot)
+      end
+
+      def chair_above(currvalue:)
+        currtier, currspot = currvalue.split("|").take(2)
+        nicespot = (currspot.to_i(BASE) - 1).to_s(BASE).rjust(currspot.length, "0")
+        nicespot = firstspot(currspot) if nicespot.to_i(BASE) == 0
+        chair(currtier, nicespot, @initial_slot)
+      end
+
+      def chair_below(currvalue:)
+        currtier, currspot = currvalue.split("|").take(2)
+        nicespot = (currspot.to_i(BASE) + 1).to_s(BASE).rjust(currspot.length, "0")
+        nicespot = finalspot(currspot) if nicespot.to_i(BASE) > finalspot(currspot).to_i(BASE)
+        chair(currtier, nicespot, @initial_slot)
+      end
+
+      def stool_above(currvalue:, prevvalue:)
+        currtier, currspot, currslot = currvalue.split("|")
+        prevtier, prevspot, prevslot = prevvalue.split("|") if prevvalue
+        stool(currtier, currspot, firstslot(currtier, prevtier, currspot, prevspot, prevslot), currslot)
+      end
+
+      def stool_below(currvalue:, nextvalue:)
+        currtier, currspot, currslot = currvalue.split("|")
+        nexttier, nextspot, nextslot = nextvalue.split("|") if nextvalue
+        stool(currtier, currspot, currslot, finalslot(currtier, nexttier, currspot, nextspot, nextslot))
+      end
+
+      private
+
+      def firstspot(currspot)
+        "0".rjust(currspot.length, "0")
+      end
+
+      def finalspot(currspot)
+        "z".rjust(currspot.length, "z")
+      end
+
+      def firstslot(currtier, prevtier, currspot, prevspot, prevslot)
+        currtier == prevtier && currspot == prevspot ? prevslot : "00"
+      end
+
+      def finalslot(currtier, nexttier, currspot, nextspot, nextslot)
+        currtier == nexttier && currspot == nextspot ? nextslot : "zz"
+      end
+
+      def chair(tier, spot, slot)
+        ["#{tier}|#{spot}|#{slot}", chairs_almost_over?(spot)]
+      end
+
+      def stool(tier, spot, slot_small, slot_big)
+        avg_slot = ((slot_big.to_i(BASE) + slot_small.to_i(BASE)) / 2).to_s(BASE).rjust(slot_big.length, "0")
+        ["#{tier}|#{spot}|#{avg_slot}", stools_almost_over?(slot_small, slot_big)]
+      end
+
+      def chairs_almost_over?(spot)
+        finalspot(spot).to_i(BASE) - spot.to_i(BASE) <= 10
+      end
+
+      # Careful, when 'true' stools are much less than 10 because of division by 2 to get the next stool.
+      def stools_almost_over?(slot_small, slot_big)
+        (slot_big.to_i(BASE) - slot_small.to_i(BASE)) <= 10
+      end
+    end
+  end
+end

data/lib/active_kit/position.rb

@@ -0,0 +1,9 @@
+module ActiveKit
+  module Position
+    extend ActiveSupport::Autoload
+
+    autoload :Harmonize
+    autoload :Positioner
+    autoload :Positioning
+  end
+end

data/lib/active_kit/version.rb

@@ -1,3 +1,3 @@
 module ActiveKit
-  VERSION = '0.2.3'
+  VERSION = '0.3.0'
 end

data/lib/active_kit.rb

@@ -4,6 +4,5 @@ require "active_kit/engine"
 module ActiveKit
   extend ActiveSupport::Autoload
 
-  autoload :Base
-  autoload :Sequence
+  autoload :Position
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activekit
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - plainsource
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-11-06 00:00:00.000000000 Z
+date: 2023-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -47,22 +47,16 @@ files:
 - app/jobs/active_kit/application_job.rb
 - app/mailers/active_kit/application_mailer.rb
 - app/models/active_kit/application_record.rb
-- app/models/active_kit/attribute.rb
 - app/views/layouts/active_kit/application.html.erb
 - config/routes.rb
-- db/migrate/20231016050208_create_active_kit_attributes.rb
 - lib/active_kit.rb
-- lib/active_kit/base.rb
-- lib/active_kit/base/activekitable.rb
-- lib/active_kit/base/activekiter.rb
-- lib/active_kit/base/ensure.rb
-- lib/active_kit/base/middleware.rb
-- lib/active_kit/base/relation.rb
 - lib/active_kit/engine.rb
-- lib/active_kit/sequence.rb
-- lib/active_kit/sequence/sequence.rb
-- lib/active_kit/sequence/sequenceable.rb
-- lib/active_kit/sequence/wordbook.rb
+- lib/active_kit/position.rb
+- lib/active_kit/position/harmonize.rb
+- lib/active_kit/position/middleware.rb
+- lib/active_kit/position/positionable.rb
+- lib/active_kit/position/positioner.rb
+- lib/active_kit/position/positioning.rb
 - lib/active_kit/version.rb
 - lib/activekit.rb
 - lib/tasks/active_kit_tasks.rake

data/app/models/active_kit/attribute.rb

@@ -1,17 +0,0 @@
-module ActiveKit
-  class Attribute < ApplicationRecord
-    belongs_to :record, polymorphic: true
-
-    store :value, accessors: [ :sequence ], coder: JSON
-
-    validates :value, presence: true, length: { maximum: 1073741823, allow_blank: true }
-
-    before_validation :set_defaults
-
-    private
-
-    def set_defaults
-      self.sequence = { attributes: {} } if self.sequence.blank?
-    end
-  end
-end

data/db/migrate/20231016050208_create_active_kit_attributes.rb

@@ -1,9 +0,0 @@
-class CreateActiveKitAttributes < ActiveRecord::Migration[6.1]
-  def change
-    create_table :active_kit_attributes do |t|
-      t.references :record, polymorphic: true, index: true
-      t.text       :value, size: :long
-      t.timestamps
-    end
-  end
-end

data/lib/active_kit/base/activekitable.rb

@@ -1,17 +0,0 @@
-require 'active_support/concern'
-require "active_kit/sequence/sequenceable"
-
-module ActiveKit
-  module Base
-    module Activekitable
-      extend ActiveSupport::Concern
-      include ActiveKit::Sequence::Sequenceable
-
-      included do
-      end
-
-      class_methods do
-      end
-    end
-  end
-end

data/lib/active_kit/base/activekiter.rb

@@ -1,13 +0,0 @@
-module ActiveKit
-  module Base
-    class Activekiter
-      def initialize(current_class:)
-        @current_class = current_class
-      end
-
-      def sequence
-        @sequence ||= ActiveKit::Sequence::Sequence.new(current_class: @current_class)
-      end
-    end
-  end
-end

data/lib/active_kit/base/ensure.rb

@@ -1,25 +0,0 @@
-module ActiveKit
-  module Base
-    class Ensure
-      def self.setup_for!(current_class:)
-        current_class.class_eval do
-          unless self.reflect_on_association :activekit_association
-            has_one :activekit_association, as: :record, dependent: :destroy, class_name: "ActiveKit::Attribute"
-
-            def activekit
-              @activekit ||= Relation.new(current_object: self)
-            end
-
-            def self.activekiter
-              @activekiter ||= Activekiter.new(current_class: self)
-            end
-          end
-        end
-      end
-
-      def self.has_one_association_for!(record:)
-        record.create_activekit_association unless record.activekit_association
-      end
-    end
-  end
-end

data/lib/active_kit/base/relation.rb

@@ -1,9 +0,0 @@
-module ActiveKit
-  module Base
-    class Relation
-      def initialize(current_object:)
-        @current_object = current_object
-      end
-    end
-  end
-end

data/lib/active_kit/base.rb

@@ -1,9 +0,0 @@
-module ActiveKit
-  module Base
-    extend ActiveSupport::Autoload
-
-    autoload :Activekiter
-    autoload :Ensure
-    autoload :Relation
-  end
-end

data/lib/active_kit/sequence/sequence.rb

@@ -1,38 +0,0 @@
-module ActiveKit
-  module Sequence
-    class Sequence
-      attr_reader :defined_attributes
-
-      def initialize(current_class:)
-        @current_class = current_class
-
-        @defined_attributes = {}
-        @wordbook = Wordbook.new
-      end
-
-      def update(record:, attribute_name:, position:)
-        ActiveKit::Base::Ensure.has_one_association_for!(record: record)
-
-        if position
-          raise "position '#{position}' is not a valid unsigned integer value greater than 0." unless position.is_a?(Integer) && position > 0
-
-          wordbook = Wordbook.new
-          word_for_position = wordbook.next_word(count: position)
-          # TODO: committer record for the attribute with given word_for_position should be found and resaved to recalculate its position.
-          # json_where = 'value->"$.sequence.attributes.' + attribute_name.to_s + '" = "' + word_for_position + '"'
-          # record_at_position = ActiveKit::Attribute.where(record_type: record.class.name).where(json_where).first&.record
-          record.activekit_association.sequence[:attributes][attribute_name.to_sym] = word_for_position
-          record.activekit_association.save!
-          # record_at_position.save! if record_at_position
-        else
-          record.activekit_association.sequence[:attributes][attribute_name.to_sym] = nil
-          record.activekit_association.save!
-        end
-      end
-
-      def add_attribute(name:, options:)
-        @defined_attributes.store(name, options)
-      end
-    end
-  end
-end

data/lib/active_kit/sequence/sequenceable.rb

@@ -1,98 +0,0 @@
-require 'active_support/concern'
-
-module ActiveKit
-  module Sequence
-    module Sequenceable
-      extend ActiveSupport::Concern
-
-      included do
-      end
-
-      class_methods do
-        # Usage Options
-        # sequence_attribute :name
-        # sequence_attribute :name, :positioning_method
-        # sequence_attribute :name, :positioning_method, updater: {}
-        # sequence_attribute :name, :positioning_method, updater: { on: {} }
-        # sequence_attribute :name, :positioning_method, updater: { via: :assoc, on: {} }
-        # sequence_attribute :name, :positioning_method, updater: { via: {}, on: {} }
-        # Note: :on and :via in :updater can accept nested associations.
-        def sequence_attribute(name, positioning_method = nil, **options)
-          ActiveKit::Base::Ensure.setup_for!(current_class: self)
-
-          name = name.to_sym
-          options.store(:positioning_method, positioning_method&.to_sym)
-          options.deep_symbolize_keys!
-
-          set_active_sequence_callbacks(attribute_name: name, options: options)
-          activekiter.sequence.add_attribute(name: name, options: options)
-        end
-
-        def set_active_sequence_callbacks(attribute_name:, options:)
-          positioning_method = options.dig(:positioning_method)
-          updater = options.dig(:updater) || {}
-
-          if updater.empty?
-            after_save do
-              position = positioning_method ? self.public_send(positioning_method) : nil
-              self.class.activekiter.sequence.update(record: self, attribute_name: attribute_name, position: position)
-              logger.info "ActiveSequence - Sequencing from #{self.class.name}: Done."
-            end
-          else
-            raise ":updater should be a hash while setting sequence_attribute. " unless updater.is_a?(Hash)
-            raise ":on in :updater should be a hash while setting sequence_attribute. " if updater.key?(:on) && !updater[:on].is_a?(Hash)
-            raise "Cannot use :via without :on in :updater while setting sequence_attribute. " if updater.key?(:via) && !updater.key?(:on)
-
-            updater_via = updater.delete(:via)
-            updater_on = updater.delete(:on) || updater
-            
-            base_klass = search_base_klass(self.name, updater_via)
-            klass = reflected_klass(base_klass, updater_on.keys.first)
-            klass.constantize.class_eval do
-              after_save    :activekit_sequence_sequenceable_callback
-              after_destroy :activekit_sequence_sequenceable_callback
-
-              define_method :activekit_sequence_sequenceable_callback do
-                inverse_assoc = self.class.search_inverse_assoc(self, updater_on)
-                position = positioning_method ? self.public_send(positioning_method) : nil
-                if inverse_assoc.respond_to?(:each)
-                  inverse_assoc.each { |instance| instance.class.activekiter.sequence.update(record: instance, attribute_name: attribute_name, position: position) }
-                else
-                  inverse_assoc.class.activekiter.sequence.update(record: inverse_assoc, attribute_name: attribute_name, position: position)
-                end
-                logger.info "ActiveSequence - Sequencing from #{self.class.name}: Done."
-              end
-              private :activekit_sequence_sequenceable_callback
-            end
-          end
-        end
-
-        def search_base_klass(classname, updater_via)
-          if updater_via.blank?
-            classname
-          elsif updater_via.is_a? Symbol
-            reflected_klass(classname, updater_via)
-          elsif updater_via.is_a? Hash
-            klass = reflected_klass(classname, updater_via.keys.first)
-            updater_via.values.first.is_a?(Hash) ? search_base_klass(klass, updater_via.values.first) : reflected_klass(klass, updater_via.values.first)
-          end
-        end
-
-        def reflected_klass(classname, key)
-          klass = classname.constantize.reflect_on_all_associations.map { |assoc| [assoc.name, assoc.klass.name] }.to_h[key]
-          raise "Could not find reflected klass for classname '#{classname}' and key '#{key}' while setting sequence_attribute" unless klass
-          klass
-        end
-
-        def search_inverse_assoc(klass_object, updater_on)
-          if updater_on.values.first.is_a?(Hash)
-            klass_object = klass_object.public_send(updater_on.values.first.keys.first)
-            search_inverse_assoc(klass_object, updater_on.values.first)
-          else
-            klass_object.public_send(updater_on.values.first)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_kit/sequence/wordbook.rb

@@ -1,60 +0,0 @@
-module ActiveKit
-  module Sequence
-    class Wordbook
-      attr_accessor :bookmark
-
-      def initialize(base: 36, length: 7, gap: 8, bookmark: nil)
-        @base = base
-        @length = length
-        @gap = gap
-
-        @first_letter = 0.to_s(@base)
-        @first_word = @first_letter.rjust(@length, @first_letter)
-
-        @last_letter = (@base - 1).to_s(@base)
-        @last_word = @last_letter.rjust(@length, @last_letter)
-
-        @bookmark = bookmark || @first_word
-      end
-
-      def previous_word(count: 1)
-        new_word(direction: :previous, count: count)
-      end
-
-      def previous_word?(count: 1)
-        previous_word(count: count).present?
-      end
-
-      def next_word(count: 1)
-        new_word(direction: :next, count: count)
-      end
-
-      def next_word?(count: 1)
-        next_word(count: count).present?
-      end
-
-      def between_word(word_one:, word_two:)
-        raise "'#{word_one}' is not in range." if (word_one.length > @length) || (word_one < @first_word || word_one > @last_word)
-        raise "'#{word_two}' is not in range." if (word_two.length > @length) || (word_two < @first_word || word_two > @last_word)
-
-        diff = word_one > word_two ? word_one.to_i(@base) - word_two.to_i(@base) : word_two.to_i(@base) - word_one.to_i(@base)
-        between_word = (diff / 2).to_s(@base)
-        between_word.rjust(@length, @first_letter)
-      end
-
-      def between_word?(word_one:, word_two:)
-        between_word(word_one: word_one, word_two: word_two).present?
-      end
-
-      private
-
-      def new_word(direction:, count:)
-        word = @bookmark.to_i(@base)
-        word = direction == :next ? word + (count * @gap) : word - (count * @gap)
-        word = word.to_s(@base).rjust(@length, @first_letter)
-        # TODO: raise exception if word is out of bound before first word or after last word.
-        word
-      end
-    end
-  end
-end

data/lib/active_kit/sequence.rb

@@ -1,8 +0,0 @@
-module ActiveKit
-  module Sequence
-    extend ActiveSupport::Autoload
-
-    autoload :Sequence
-    autoload :Wordbook
-  end
-end