activekit 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f22601f05c64e21478512fd85ac1ebf74afc91c517349793fc79bfad4f343952
-  data.tar.gz: 3ed1dcb02993f21dd6cb582b2574652eb34a5107e4d70c456ba047391294a908
+  metadata.gz: 98f08d0d1d37f5f2e3968da22af8cb3feb20704f5f5f6c6cf02d838fd2560354
+  data.tar.gz: ee3805f8d06d399c9519d0ae0360ee07f1069400033638eea6c2f9cfce519aac
 SHA512:
-  metadata.gz: 78245200325e89c2a78a83123c2874bb9163d2202fdf9719b62f60d9986274a6ddb9e1700801cb2d7be896aaff90d782f79e43c9e6681c8720192e14e4738acd
-  data.tar.gz: d770761da113c6f859e04250a980f3c4416ff142702ab2f97b88ca32bc063cb4f32e9967e0fa2c2b4deac10e5d4d63c392e00c5462f31a586aefa355b3f87918
+  metadata.gz: 6dc11428da73f1875bec2250f402df9e67053903b5b6c1762190fcf72f3c16d8f76f42c34bfcd34d9b9b5ecdf534d8d71d6bafbcd059dfe1c968652bfc8490f2
+  data.tar.gz: 73521d96b3200bbeaae1edda274ed4eff23154b66c8206b888b3ce540eb55d92a351925c628e4e4bcbbcfe3f007a23a945e12fbda6581c233d199b7a26150cae

data/app/models/active_kit/attribute.rb

@@ -2,6 +2,16 @@ 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/lib/active_kit/activekitable.rb

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

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

@@ -3,11 +3,11 @@ module ActiveKit
     isolate_namespace ActiveKit
     config.eager_load_namespaces << ActiveKit
 
-    initializer "active_kit.sequence" do
-      require "active_kit/sequence/sequenceable"
+    initializer "active_kit.activekitable" do
+      require "active_kit/activekitable"
 
       ActiveSupport.on_load(:active_record) do
-        include ActiveKit::Sequence::Sequenceable
+        include ActiveKit::Activekitable
       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,37 @@
+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)
+          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,40 +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 ||= 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)
+          set_active_sequence_callbacks(attribute_name: name, options: options)
+          activekiter.sequence.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 || {}
+        def set_active_sequence_callbacks(attribute_name:, options:)
+          positioning_method = options.dig(:positioning_method)
+          updater = options.dig(: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)
+              self.class.activekiter.sequence.update(record: self, attribute_name: attribute_name, position: position)
               logger.info "ActiveSequence - Sequencing from #{self.class.name}: Done."
             end
           else
@@ -61,20 +46,20 @@ 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)
+                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
 
@@ -84,8 +69,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
 
@@ -96,11 +81,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

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

data/lib/active_kit/version.rb

@@ -1,3 +1,3 @@
 module ActiveKit
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

data/lib/active_kit.rb

@@ -4,6 +4,8 @@ require "active_kit/engine"
 module ActiveKit
   extend ActiveSupport::Autoload
 
-  autoload :Sequencer, "active_kit/sequence/sequencer"
-  autoload :Wordbook, "active_kit/sequence/wordbook"
+  autoload :Activekiter
+  autoload :Loader
+  autoload :Relation
+  autoload :Sequence
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activekit
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - plainsource
@@ -52,9 +52,14 @@ files:
 - config/routes.rb
 - 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