activekit 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfed47304194f32cec27e3c9fa345f1da862d3778591e9bd2abca1dbb72be09f
-  data.tar.gz: d49567af80349c8c0433e102ccc72fd2399667dcac11511e6b1b2c7a7436a41f
+  metadata.gz: d79cd1518b90bb64257a77318f59cfa3f2bfa9bb58a45ead89ddfa5bcb08b001
+  data.tar.gz: c8891e2351e0940b765a0a5c296403f2885fac4b64db00b822d32707f84b156c
 SHA512:
-  metadata.gz: a98525862f0a8aecfd0b9c02d51903e45a8977634fb8b3a489982b5465d8dc00ad6581c36f6b740fac413c7708be4ac38726a8fd5b3f49ee4ac1b1b8148103e5
-  data.tar.gz: 349abf115fed3456d6e996ac52480941d9774ec06cdeef96c821d6d17298b8b81d94176aa08aafbe92bfab3c713d7a6563c35c1258aa958828366824367cc488
+  metadata.gz: 83975dd7d4e472532c0b1afa3afcf2aebda640093f6cedb325c9b69adc50f8216e8cc59edaea6f2d923320be8e7409e026c3d36ba48f29469acec41a97bf609b
+  data.tar.gz: 6bb3596f95f6893e9ce5a342b96ac22ed2d72cf36866900fa75fedb8a6a397020c0d3295160f1ddca8bee1a36921adf3e055d0e65b1b7d6d60caa6dc7975401b

data/lib/active_kit/engine.rb

@@ -1,5 +1,14 @@
 module ActiveKit
   class Engine < ::Rails::Engine
     isolate_namespace ActiveKit
+    config.eager_load_namespaces << ActiveKit
+
+    initializer "active_kit.sequence" do
+      require "active_kit/sequence/sequenceable"
+
+      ActiveSupport.on_load(:active_record) do
+        include ActiveKit::Sequence::Sequenceable
+      end
+    end
   end
 end

data/lib/active_kit/sequence/sequenceable.rb

@@ -0,0 +1,109 @@
+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, **options)
+          name = name.to_sym
+          positioning_method = positioning_method.to_sym
+          options.deep_symbolize_keys!
+
+          unless self.respond_to?(:sequencer)
+            define_singleton_method :sequencer do
+              @sequencer ||= ActiveSequence::Sequencer.new(current_class: self)
+            end
+
+            has_many :sequence_attributes, as: :record, dependent: :destroy, class_name: "ActiveSequence::Attribute"
+            # scope :order_sequence, -> (options_hash) { includes(:sequence_attributes).where(sequence_attributes: { name: name.to_s }).order("sequence_attributes.value": :asc) } 
+          end
+
+          set_active_sequence_create_callbacks(attribute_name: name)
+          set_active_sequence_commit_callbacks(attribute_name: name, positioning_method: positioning_method, updater: options.delete(:updater))
+
+          sequencer.add_attribute(name: name, options: options)
+        end
+
+        def set_active_sequence_create_callbacks(attribute_name:)
+          before_create do
+            self.sequence_attributes.find_or_initialize_by(name: attribute_name)
+            logger.info "ActiveSequence - Creating Sequence attribute '#{attribute}' from #{self.class.name}: Done."
+          end
+        end
+
+        def set_active_sequence_commit_callbacks(attribute_name:, positioning_method:, updater:)
+          updater = updater || {}
+
+          if updater.empty?
+            after_commit do
+              position = positioning_method ? self.public_send(positioning_method) : nil
+              self.class.sequencer.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.class.name, updater_via)
+            klass = reflected_klass(base_klass, updater_on.key)
+            klass.constantize.class_eval do
+              after_commit do
+                inverse_assoc = 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.sequencer.update(record: instance, attribute_name: attribute_name, position: position) }
+                else
+                  inverse_assoc.class.sequencer.update(record: inverse_assoc, attribute_name: attribute_name, position: position)
+                end
+                logger.info "ActiveSequence - Sequencing from #{self.class.name}: Done."
+              end
+            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.key)
+            updater_via.value.is_a?(Hash) ? search_base_klass(klass, updater_via.value) : reflected_klass(klass, updater_via.value)
+          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.value.is_a?(Hash)
+            klass_object = klass_object.public_send(updater_on.value.key)
+            search_inverse_assoc(klass_object, updater_on.value)
+          else
+            klass_object.public_send(updater_on.value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_kit/sequence/sequencer.rb

@@ -0,0 +1,69 @@
+module ActiveKit
+  module Sequence
+    class Sequencer
+      attr_reader :defined_attributes
+
+      def initialize(current_class:)
+        @current_class = current_class
+
+        @defined_attributes = {}
+        @wordbook = Wordbook.new
+      end
+
+      def update(record:, attribute_name:, position:)
+        attribute = Attribute.find_by(record: record, name: attribute_name)
+        Attribute.create!(record: record, name: attribute_name) unless attribute
+
+        if position
+          raise "position '#{position}' is not a valid unsigned integer value greater than 0." unless position.is_a?(Integer) && position > 0
+
+          attribute_at_position = Attribute.where(record_type: record.class.name, name: attribute_name).order(value: :asc).offset(position - 1).limit(1)
+          attribute
+
+          wordbook = Wordbook.new
+          total_position_count = Attribute.where(record_type: record.class.name, name: attribute_name).order(value: :asc).count
+          if attribute == attribute_at_position(position)
+            return
+          elsif position == 1
+
+          elsif position == total_position_count
+            wordbook.bookmark = attribute_at_position(total_position_count).value
+
+            attribute.value = wordbook.next_word if wordbook.next_word?
+            attribute.save!
+          elsif position > total_position_count
+            maximum_word = Attribute.where(record_type: record.class.name, name: attribute_name).maximum(:value)
+
+            wordbook.bookmark = maximum_word
+            attribute.value = wordbook.next_word if wordbook.next_word?
+            attribute.save!
+          elsif position < total_position_count
+
+          end
+        end
+      end
+
+      def rebalance_from(position:)
+        ActiveRecord::Base.transaction do
+          wordbook = Wordbook.new
+          Attribute.where(record_type: record.class.name, name: attribute_name).order(value: :asc).offset(position - 1).limit(1)
+          Attribute.where(record_type: record.class.name, name: attribute_name).order(value: :asc).offset(position - 1).each do |attribute|
+            wordbook.bookmark = attribute.value
+            raise "Could not find next word in wordbook while rebalancing" unless wordbook.next_word?
+
+            attribute.value = wordbook.next_word
+            attribute.save!
+          end
+        end
+      end
+
+      def attribute_at_position(position)
+        Attribute.where(record_type: record.class.name, name: attribute_name).order(value: :asc).offset(position - 1).limit(1)
+      end
+
+      def add_attribute(name:, options:)
+        @defined_attributes.store(name, options)
+      end
+    end
+  end
+end

data/lib/active_kit/sequence/wordbook.rb

@@ -0,0 +1,60 @@
+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/version.rb

@@ -1,3 +1,3 @@
 module ActiveKit
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/lib/active_kit.rb

@@ -2,4 +2,8 @@ require "active_kit/version"
 require "active_kit/engine"
 
 module ActiveKit
+  extend ActiveSupport::Autoload
+
+  autoload :Sequencer, "active_kit/sequence/sequencer"
+  autoload :Wordbook, "active_kit/sequence/wordbook"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activekit
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - plainsource
@@ -51,6 +51,9 @@ files:
 - config/routes.rb
 - lib/active_kit.rb
 - lib/active_kit/engine.rb
+- lib/active_kit/sequence/sequenceable.rb
+- lib/active_kit/sequence/sequencer.rb
+- lib/active_kit/sequence/wordbook.rb
 - lib/active_kit/version.rb
 - lib/activekit.rb
 - lib/tasks/active_kit_tasks.rake