activekit 0.2.3.dev1 → 0.2.3.dev2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdfebffac9f65f7b8e393240aebefc53bb56d46a1eaff8070837735adf269e99
-  data.tar.gz: 331f0bef2a0675a603bf462885b7bf0c47a5acca2efcc8a59db8150555183bdd
+  metadata.gz: 95241693c8cee6d5b29f2f8172abf1a5b31f70ea29a529595db9d5f71d24b948
+  data.tar.gz: e00f4986129a42c3444daee94921081738e763f9edd9de704567b0f9aab7eb3e
 SHA512:
-  metadata.gz: f814ff88427a48347b5272a7cec69997fed42d5910a9fa708fdd45b7e19957ebd6df5b1d0a12d025bcd7bf65d99e630aa2ed879ac7b3e5c50ddbf043c7bcdf55
-  data.tar.gz: b79dc6fa0fd3d62e7f03fe0e69426969d77380614e4c3b64a1fec5c21162ae7440a4fc23d2af922370474ad8dc4a6b38ed615c0dc2f3425349ef7138a426e03f
+  metadata.gz: 29b391870a0332435dcfdd39aa7995483689e5bb1b1c3a54fe81b7a0ace8165295f953b2afd82bf973e152b63cfb9d396a4a9dedc99bcaeb12e1d93b0682fa07
+  data.tar.gz: b9855efff5f9d7de6e0ec73f5dde1f501cab9cba507d2a0d7914fc2920e66443553df7ade87b411e0fbb2fdcbb5141c49a4687e5a0a505d37d4e77ee2ff6844b

data/lib/active_kit/{activekitable.rb → base/activekitable.rb}

@@ -2,9 +2,9 @@ require 'active_support/concern'
 require "active_kit/sequence/sequenceable"
 
 module ActiveKit
+  module Base
     module Activekitable
       extend ActiveSupport::Concern
-      include ActiveKit::Loader
       include ActiveKit::Sequence::Sequenceable
 
       included do
@@ -13,4 +13,5 @@ module ActiveKit
       class_methods do
       end
     end
+  end
 end

data/lib/active_kit/base/activekiter.rb

@@ -0,0 +1,17 @@
+module ActiveKit
+  module Base
+    class Activekiter
+      def initialize(current_class:)
+        @current_class = current_class
+      end
+
+      def schedule
+        @schedule ||= ActiveKit::Schedule::Schedule.new(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

@@ -0,0 +1,29 @@
+module ActiveKit
+  module Base
+    class Ensure
+      def self.middleware_for!(request:)
+        ActiveKit::Schedule::Middleware.run
+      end
+
+      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/middleware.rb

@@ -0,0 +1,26 @@
+module ActiveKit
+  module Base
+    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_runner(request) do
+          @app.call(env)
+        end
+      end
+
+      private
+
+      def activekit_runner(request, &blk)
+        Ensure.middleware_for!(request: request)
+
+        yield
+      end
+    end
+  end
+end

data/lib/active_kit/base/relation.rb

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

data/lib/active_kit/base.rb

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

data/lib/active_kit/engine.rb

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

data/lib/active_kit/schedule/middleware.rb

@@ -0,0 +1,12 @@
+module ActiveKit
+  module Schedule
+    class Middleware
+      def self.run(request:)
+        logger.info "coming from middleware of activekit schedule"
+        # activekit_attribute = ActiveKit::Attribute.where(value: schedule: timestamp < DateTime.now).order(updated_at: :desc)
+        # json_where = 'value->"$.schedule.attributes.' + attribute_name.to_s + '" = "' + word_for_position + '"'
+        # record_at_position = ActiveKit::Attribute.where(record_type: record.class.name).where(json_where).first&.record
+      end
+    end
+  end
+end

data/lib/active_kit/schedule/schedule.rb

@@ -0,0 +1,24 @@
+module ActiveKit
+  module Schedule
+    class Schedule
+      attr_reader :defined_attributes
+
+      def initialize(current_class:)
+        @current_class = current_class
+
+        @defined_attributes = {}
+      end
+
+      def add(record:, attribute_name:, datetime:, method:)
+        ActiveKit::Base::Ensure.has_one_association_for!(record: record)
+
+        record.activekit_association.schedule[:attributes][attribute_name.to_sym] = nil
+        record.activekit_association.save!
+      end
+
+      def add_attribute(name:, options:)
+        @defined_attributes.store(name, options)
+      end
+    end
+  end
+end

data/lib/active_kit/schedule/scheduleable.rb

@@ -0,0 +1,97 @@
+require 'active_support/concern'
+
+module ActiveKit
+  module Schedule
+    module Scheduleable
+      extend ActiveSupport::Concern
+
+      included do
+      end
+
+      class_methods do
+        # Usage Options
+        # schedule_attribute :name, :run_method, :begin_at, :end_at
+        # schedule_attribute :name, :run_method, :timestamp_method, updater: {}
+        # schedule_attribute :name, :run_method, :timestamp_method, updater: { on: {} }
+        # schedule_attribute :name, :run_method, :timestamp_method, updater: { via: :assoc, on: {} }
+        # schedule_attribute :name, :run_method, :timestamp_method, updater: { via: {}, on: {} }
+        # Note: :on and :via in :updater can accept nested associations.
+        def schedule_attribute(name, run_method, timestamp_method, interval, **options)
+          ActiveKit::Base::Ensure.setup_for!(current_class: self)
+
+          name = name.to_sym
+          options.store(:run_method, run_method&.to_sym)
+          options.store(:timestamp_method, datetime_method&.to_sym)
+          options.deep_symbolize_keys!
+
+          set_activekit_schedule_callbacks(name: name, options: options)
+          activekiter.schedule.add_attribute(name: name, options: options)
+        end
+
+        def set_activekit_schedule_callbacks(name:, options:)
+          run_method = options.dig(:run_method)
+          updater = options.dig(:updater) || {}
+
+          if updater.empty?
+            after_save do
+              self.class.activekiter.schedule.update(record: self, name: name, run_method: run_method)
+              logger.info "ActiveKit | Schedule - Scheduling 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/schedule.rb

@@ -0,0 +1,8 @@
+module ActiveKit
+  module Schedule
+    extend ActiveSupport::Autoload
+
+    autoload :Middleware
+    autoload :Schedule
+  end
+end

data/lib/active_kit/sequence/sequence.rb

@@ -11,7 +11,7 @@ module ActiveKit
       end
 
       def update(record:, attribute_name:, position:)
-        ActiveKit::Loader.ensure_has_one_association_for!(record: record)
+        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

data/lib/active_kit/sequence/sequenceable.rb

@@ -18,7 +18,7 @@ module ActiveKit
         # 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::Loader.ensure_setup_for!(current_class: self)
+          ActiveKit::Base::Ensure.setup_for!(current_class: self)
 
           name = name.to_sym
           options.store(:positioning_method, positioning_method&.to_sym)

data/lib/active_kit/version.rb

@@ -1,3 +1,3 @@
 module ActiveKit
-  VERSION = '0.2.3.dev1'
+  VERSION = '0.2.3.dev2'
 end

data/lib/active_kit.rb

@@ -4,9 +4,7 @@ require "active_kit/engine"
 module ActiveKit
   extend ActiveSupport::Autoload
 
-  autoload :Activekiter
-  autoload :Loader
-  autoload :Middleware
-  autoload :Relation
+  autoload :Base
+  autoload :Schedule
   autoload :Sequence
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activekit
 version: !ruby/object:Gem::Version
-  version: 0.2.3.dev1
+  version: 0.2.3.dev2
 platform: ruby
 authors:
 - plainsource
@@ -52,12 +52,17 @@ 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/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/loader.rb
-- lib/active_kit/middleware.rb
-- lib/active_kit/relation.rb
+- lib/active_kit/schedule.rb
+- lib/active_kit/schedule/middleware.rb
+- lib/active_kit/schedule/schedule.rb
+- lib/active_kit/schedule/scheduleable.rb
 - lib/active_kit/sequence.rb
 - lib/active_kit/sequence/sequence.rb
 - lib/active_kit/sequence/sequenceable.rb

data/lib/active_kit/activekiter.rb

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

@@ -1,26 +0,0 @@
-module ActiveKit
-  module Loader
-    def self.ensure_middleware_for!(request:)
-    end
-
-    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/middleware.rb

@@ -1,24 +0,0 @@
-module ActiveKit
-  class Middleware
-    def initialize(app)
-      @app = app
-    end
-
-    # Middleware that determines which ActiveKit schedules to run.
-    def call(env)
-      request = ActionDispatch::Request.new(env)
-
-      activekit_runner(request) do
-        @app.call(env)
-      end
-    end
-
-    private
-
-    def activekit_runner(request, &blk)
-      ActiveKit::Loader.ensure_middleware_for!(request: request)
-
-      yield
-    end
-  end
-end

data/lib/active_kit/relation.rb

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