activekit 0.1.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf28e084bf1e87d21b36b3abcce5f3ebc902595a9635396f985c3935467e6b48
-  data.tar.gz: ee2abf2cd217e523b35aa980dfa84072dee883dde5a2a782f864453740448321
+  metadata.gz: 67eb8f62ef1b3e4f6532c5431730922130158646b4067ed14511314777d18448
+  data.tar.gz: 11d7429b7011c2aca230935789489c4ac6828ff60e4cb250fe18910fd14d2daf
 SHA512:
-  metadata.gz: f9848ed64694d379141ab41865234ac80f6042452be9a3a34ee2f94db61fa7a9c4e3bd564fb85c6029bd7e86379e773fc5b3945a7676ea4955489cd325a72bd4
-  data.tar.gz: 8724f2eb4848df56dd589ad04e241c8a95a47d27b80e2d3c7bc1838f4b02a76e726115c27c03f449699c40ca34c8f50667254b1056408dea42bf02e5aafa5bc0
+  metadata.gz: 63885175b26d2bace31dd3ded154ab4631819645f4c2cc41653e57179968f03149f2f352c399c9693bb69bbc476e322f3c7ef67e9e4f159e956111bc478fde7c
+  data.tar.gz: fdd159ca5f30a970452036b5d8fd8eb384466dc908c166b7873144a2cee0f3c6cd8b671b23813db22073b389dbb916469576c8eef3cd0a44d1ca80e844507372

data/app/models/active_kit/attribute.rb

@@ -5,5 +5,13 @@ module ActiveKit
     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/lib/active_kit/activekitable.rb

@@ -4,6 +4,7 @@ require "active_kit/sequence/sequenceable"
 module ActiveKit
     module Activekitable
       extend ActiveSupport::Concern
+      include ActiveKit::Loader
       include ActiveKit::Sequence::Sequenceable
 
       included do

data/lib/active_kit/activekiter.rb

@@ -0,0 +1,11 @@
+module ActiveKit
+  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

data/lib/active_kit/engine.rb

@@ -8,8 +8,6 @@ module ActiveKit
 
       ActiveSupport.on_load(:active_record) do
         include ActiveKit::Activekitable
-
-        has_one :activekit, as: :record, dependent: :destroy, class_name: "ActiveKit::Attribute"
       end
     end
   end

data/lib/active_kit/loader.rb

@@ -0,0 +1,23 @@
+module ActiveKit
+  module Loader
+    def self.ensure_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.ensure_has_one_association_for!(record:)
+      record.create_activekit_association unless record.activekit_association
+    end
+  end
+end

data/lib/active_kit/relation.rb

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

data/lib/active_kit/sequence/sequence.rb

@@ -0,0 +1,38 @@
+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::Loader.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

@@ -17,31 +17,25 @@ module ActiveKit
         # 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)
+        def sequence_attribute(name, positioning_method = nil, **options)
+          ActiveKit::Loader.ensure_setup_for!(current_class: self)
+
           name = name.to_sym
-          positioning_method = positioning_method.to_sym
+          options.store(:positioning_method, positioning_method&.to_sym)
           options.deep_symbolize_keys!
 
-          unless self.respond_to?(:sequencer)
-            define_singleton_method :sequencer do
-              @sequencer ||= ActiveKit::Sequence::Sequencer.new(current_class: self)
-            end
-
-            # scope :order_sequence, -> (options_hash) { includes(:sequence_attributes).where(sequence_attributes: { name: name.to_s }).order("sequence_attributes.value": :asc) } 
-          end
-
-          set_active_sequence_callbacks(attribute_name: name, positioning_method: positioning_method, updater: options.delete(:updater))
-
-          sequencer.add_attribute(name: name, options: options)
+          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:, positioning_method:, updater:)
-          updater = updater || {}
+        def set_active_sequence_callbacks(attribute_name:, options:)
+          positioning_method = options.dig(:positioning_method)
+          updater = options.dig(:updater) || {}
 
           if updater.empty?
-            after_commit do
+            after_save do
               position = positioning_method ? self.public_send(positioning_method) : nil
-              self.class.sequencer.update(record: self, attribute_name: attribute_name, position: position)
+              self.class.activekiter.sequence.update(record: self, attribute_name: attribute_name, position: position)
               logger.info "ActiveSequence - Sequencing from #{self.class.name}: Done."
             end
           else
@@ -52,20 +46,23 @@ module ActiveKit
             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)
+            base_klass = search_base_klass(self.name, updater_via)
+            klass = reflected_klass(base_klass, updater_on.keys.first)
             klass.constantize.class_eval do
-              after_commit do
-                inverse_assoc = search_inverse_assoc(self, updater_on)
+              after_save    :activekit_sequence_sequenceable_callback
+              after_destroy :activekit_sequence_sequenceable_callback
+
+              private def activekit_sequence_sequenceable_callback
+                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.sequencer.update(record: instance, attribute_name: attribute_name, position: position) }
+                  inverse_assoc.each { |instance| instance.class.activekiter.sequence.update(record: instance, attribute_name: attribute_name, position: position) }
                 else
-                  inverse_assoc.class.sequencer.update(record: inverse_assoc, attribute_name: attribute_name, position: position)
+                  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
-            end          
+            end
           end
         end
 
@@ -75,8 +72,8 @@ module ActiveKit
           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)
+            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
 
@@ -87,11 +84,11 @@ module ActiveKit
         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)
+          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.value)
+            klass_object.public_send(updater_on.values.first)
           end
         end
       end

data/lib/active_kit/sequence.rb

@@ -2,7 +2,7 @@ module ActiveKit
   module Sequence
     extend ActiveSupport::Autoload
 
-    autoload :Sequencer
+    autoload :Sequence
     autoload :Wordbook
   end
 end

data/lib/active_kit/version.rb

@@ -1,3 +1,3 @@
 module ActiveKit
-  VERSION = '0.1.3'
+  VERSION = '0.2.1'
 end

data/lib/active_kit.rb

@@ -4,5 +4,8 @@ require "active_kit/engine"
 module ActiveKit
   extend ActiveSupport::Autoload
 
+  autoload :Activekiter
+  autoload :Loader
+  autoload :Relation
   autoload :Sequence
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activekit
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.1
 platform: ruby
 authors:
 - plainsource
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-16 00:00:00.000000000 Z
+date: 2023-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -53,10 +53,13 @@ files:
 - db/migrate/20231016050208_create_active_kit_attributes.rb
 - lib/active_kit.rb
 - lib/active_kit/activekitable.rb
+- lib/active_kit/activekiter.rb
 - lib/active_kit/engine.rb
+- lib/active_kit/loader.rb
+- lib/active_kit/relation.rb
 - lib/active_kit/sequence.rb
+- lib/active_kit/sequence/sequence.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

data/lib/active_kit/sequence/sequencer.rb

@@ -1,69 +0,0 @@
-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