isomorfeus-operation 2.5.5 → 22.9.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88039cb23105a0035cee17b77b44dac75936618387151e7088f6dcaa51669003
-  data.tar.gz: c12f46a8e826503a0c1369a9699ef5360b1d11e8788e1d238084bd3f49c34793
+  metadata.gz: ed8b7a6bb38fd8be23ca7700ace4406d1935c1293e989a067d6d90fa4094494f
+  data.tar.gz: 7143a91a4aeec61783850017f4e9f5350256aca9704aa52d02d15c447e0f54be
 SHA512:
-  metadata.gz: 0b9b7b8e34b84ca00227c7705e55d72b2338421069b5ff5373cfbbf717f8ccdec01e25036827b4ff47337af809f21a237116216765abf63e1478d039d13b3e43
-  data.tar.gz: 9d74af0f5c3816564e2d2ed70193d53f75bd87cf201a9a7daa277600199c17f6476965c1ea626047f638355c66b7b98712d26b5c517e9895b485d28bcd7e20c0
+  metadata.gz: 55667be961cac8cc70f2e4089549f1e3ac358b4a69307f8cb08d224c91052eecb2a28400c9a21e85b9d39fd0e948e0ef3428a871a5dae5ad6346e065d1241372
+  data.tar.gz: d741a0fea05377857ed1fba3d1a6247ceecff187f6cc2ce610a20912c0f8cbe32a6654f4145451800f4356f10753e9a9f617232d310e763e78b97e756dbf04a4

data/lib/isomorfeus/operation/config.rb

@@ -30,7 +30,7 @@ module Isomorfeus
       def pop_failed_tasks
         failed_tasks = []
         [Isomorfeus::Operation::DeferredTask, Isomorfeus::Operation::DailyTask].each do |task_class|
-          task_class.search(:state, 'failed').each do |task|
+          task_class.search(:failed).each do |task|
             failed_tasks << task
             task.destroy
           end
@@ -41,7 +41,7 @@ module Isomorfeus
       def all_tasks
         all_tasks = []
         [Isomorfeus::Operation::DeferredTask, Isomorfeus::Operation::DailyTask].each do |task_class|
-          task_class.search(:state, '*').each do |task|
+          task_class.search(:all).each do |task|
             all_tasks << task
           end
         end

data/lib/isomorfeus/operation/daily_task.rb

@@ -1,7 +1,13 @@
 module Isomorfeus
   module Operation
-    class DailyTask < LucidObject::Base
+    class DailyTask < LucidObject
       STATES = %w[ready running failed]
+
+      query :ready, 'state:"ready"'
+      query :running, 'state:"running"'
+      query :failed, 'state:"failed"'
+      query :all, 'state:*'
+
       # when the task is added to the queue its added as ready
       # when its running, its running
       # when it failes, it failed, the exception attribute is filled

data/lib/isomorfeus/operation/deferred_task.rb

@@ -1,7 +1,13 @@
 module Isomorfeus
   module Operation
-    class DeferredTask < LucidObject::Base
+    class DeferredTask < LucidObject
       STATES = %w[ready running failed]
+
+      query :ready, 'state:"ready"'
+      query :running, 'state:"running"'
+      query :failed, 'state:"failed"'
+      query :all, 'state:*'
+
       # when the task is added to the queue its added as ready
       # when its running, its running
       # when it failes, it failed, the exception attribute is filled

data/lib/isomorfeus/operation/generic_class_api.rb

@@ -28,13 +28,13 @@ module Isomorfeus
 
         def promise_run(**props_hash)
           props = validated_props(props_hash)
-          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, :run, props)
+          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler', self.name, :run, props)
             .then { |agent| _process_response(agent) }
         end
 
         def promise_deferred(**props_hash)
           props = validated_props(props_hash)
-          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, :deferred, props)
+          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler', self.name, :deferred, props)
             .then { |agent| _process_response(agent) }
         end
 
@@ -42,19 +42,17 @@ module Isomorfeus
           key = props_hash.delete(:key)
           props = validated_props(props_hash)
           props[:key] = key if key
-          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, :daily, props)
+          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler', self.name, :daily, props)
             .then { |agent| _process_response(agent) }
         end
 
-        def promise_remove_daily(**props_hash)
-          raise "key: must be given" unless props_hash.key?(:key)
-          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, :remove_daily, props_hash)
+        def promise_remove_daily(key:)
+          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler', self.name, :remove_daily, key: key)
             .then { |agent| _process_response(agent) }
         end
 
-        def promise_daily_exist?(**props_hash)
-          raise "key: must be given" unless props_hash.key?(:key)
-          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, :daily_exist, props_hash)
+        def promise_daily_exist?(key:)
+          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler', self.name, :daily_exist, key: key)
             .then { |agent| _process_response(agent) }
         end
       else
@@ -75,17 +73,13 @@ module Isomorfeus
           Promise.new.resolve(task.key)
         end
 
-        def promise_remove_daily(**props_hash)
-          raise "key: must be given" unless props_hash.key?(:key)
-          key = props_hash.delete(:key)
+        def promise_remove_daily(key:)
           Isomorfeus::Operation::DailyTask.destroy(key: key)
           Promise.new.resolve(true)
         end
 
-        def promise_daily_exist?(**props_hash)
-          raise "key: must be given" unless props_hash.key?(:key)
-          key = props_hash.delete(:key)
-          have_task = !!Isomorfeus::Operation::DailyTask.load(key: key)
+        def promise_daily_exist?(key:)
+          have_task = !!Isomorfeus::Operation::DailyTask.exist?(key: key)
           Promise.new.resolve(have_task)
         end
       end

data/lib/isomorfeus/operation/handler.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Isomorfeus
+  module Operation
+    class Handler < LucidHandler
+      on_request do |response_agent|
+        # promise_send_path('Isomorfeus::Operation::Handler', self.to_s, props_hash)
+        response_agent.request.each_key do |operation_class_name|
+          if Isomorfeus.valid_operation_class_name?(operation_class_name)
+            operation_class = Isomorfeus.cached_operation_class(operation_class_name)
+            if operation_class
+              response_agent.request[operation_class_name].each_key do |method|
+                props = response_agent.request[operation_class_name][method]
+                props.transform_keys!(&:to_sym)
+                begin
+                  case method
+                  when 'run'
+                    raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_run, props)
+                    operation_promise = operation_class.promise_run(**props)
+                    if operation_promise.realized?
+                      state = operation_promise.resolved? ? :resolved : :rejected
+                      result_hash = { state => operation_promise.value }
+                      if operation_promise.error
+                        e = operation_promise.error
+                        result_hash[:error] = { message: e.message, class_name: e.class.to_s, back_trace: e.backtrace }
+                      end
+                      response_agent.agent_result = { success: 'ok' , result: result_hash }
+                    else
+                      start = Time.now
+                      timeout = false
+                      while !operation_promise.realized?
+                        if (Time.now - start) > 20
+                          timeout = true
+                          break
+                        end
+                        sleep 0.01
+                      end
+                      if timeout
+                        response_agent.error = { error: 'Timeout' }
+                      else
+                        state = operation_promise.resolved? ? :resolved : :rejected
+                        result_hash = { state => operation_promise.value }
+                        if operation_promise.error
+                          e = operation_promise.error
+                          result_hash[:error] = { message: e.message, class_name: e.class.to_s, back_trace: e.backtrace }
+                        end
+                        response_agent.agent_result = { success: 'ok' , result: result_hash }
+                      end
+                    end
+                  when 'deferred'
+                    raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_deferred, props)
+                    operation_promise = operation_class.promise_deferred(**props)
+                    response_agent.agent_result = { success: 'ok' , result: { :resolved => operation_promise.value }}
+                  when 'daily'
+                    raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_daily, props)
+                    operation_promise = operation_class.promise_daily(**props)
+                    response_agent.agent_result = { success: 'ok' , result: { :resolved => operation_promise.value }}
+                  when 'remove_daily'
+                    raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_daily, props)
+                    operation_promise = operation_class.promise_remove_daily(**props)
+                    response_agent.agent_result = { success: 'ok' , result: { :resolved => operation_promise.value }}
+                  when 'daily_exist'
+                    raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_daily, props)
+                    operation_promise = operation_class.promise_daily(**props)
+                    response_agent.agent_result = { success: 'ok' , result: { :resolved => operation_promise.value }}
+                  else
+                    response_agent.error = { error: 'No such method!' }
+                  end
+                rescue Exception => e
+                  response_agent.error = { error: { operation_class_name => "Isomorfeus::Operation::Handler: #{e.message}" }}
+                end
+              end
+            else
+              response_agent.error = { error: { operation_class_name => 'Could not get operation class!' }}
+            end
+          else
+            response_agent.error = { error: { operation_class_name => 'No such operation class!' }}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/operation/init_timer_tasks.rb

@@ -8,6 +8,6 @@ Isomorfeus.operation_timer_tasks[:daily] = Concurrent::TimerTask.new(execution_i
   Isomorfeus::Operation::RunTask.new(Isomorfeus::Operation::DailyTask, timer_task: timer_task, interval: 86400, recurring: true).run
 end
 
-Isomorfeus.operation_timer_tasks.each do |k, t|
+Isomorfeus.operation_timer_tasks.each_value do |t|
   t.execute
 end

data/lib/isomorfeus/operation/run_task.rb

@@ -9,29 +9,41 @@ module Isomorfeus
       end
 
       def run
+        Isomorfeus.init_store
+        Isomorfeus.store.clear!
         @rtime = Time.now
         tasks = get_tasks
         tasks.each do |task|
           marked = mark_as_running(task)
           if marked
             begin
-              operation_class = task.operation_class_name.constantize
-              user_class_name = task.user_class_name
-              Thread.current[:isomorfeus_user] = if user_class_name == 'LocalSystem'
-                                                   LocalSystem.new
-                                                 elsif Isomorfeus.valid_user_class_name?(user_class_name)
-                                                   user_class = user_class_name.constantize
-                                                   user_class.load(key: task.user_key) || Anonymous.new
-                                                 else
-                                                   Anonymous.new
-                                                 end
-              raise 'Access denied!' unless Thread.current[:isomorfeus_user].authorized?(operation_class, :promise_run, task.props)
+              operation_class = task[:operation_class_name].constantize
+              user_class_name = task[:user_class_name]
+              user_instance = if user_class_name == 'LocalSystem'
+                                LocalSystem.new
+                              elsif user_class_name == 'Anonymous'
+                                Anonymous.new
+                              elsif Isomorfeus.valid_user_class_name?(user_class_name)
+                                user_class = user_class_name.constantize
+                                cu = Thread.current[:isomorfeus_user]
+                                Thread.current[:isomorfeus_user] = LocalSystem.new
+                                begin
+                                  u = user_class.load(key: task[:user_key]) || Anonymous.new
+                                ensure
+                                  Thread.current[:isomorfeus_user] = cu
+                                end
+                                u
+                              else
+                                Anonymous.new
+                              end
+              Thread.current[:isomorfeus_user] = user_instance
+              raise 'Access denied!' unless Thread.current[:isomorfeus_user].authorized?(operation_class, :promise_run, task[:props])
               if @recurring
-                operation_class.promise_run(**task.props)
+                operation_class.promise_run(**task[:props])
                   .then { mark_as_ready(task) }
-                  .fail { |e| task.fail ? mark_as_failed(task, e) : save_exception(task, e) }
+                  .fail { |e| task[:fail] ? mark_as_failed(task, e) : save_exception(task, e) }
               else
-                operation_class.promise_run(**task.props)
+                operation_class.promise_run(**task[:props])
                 .then { remove_task(task) }
                 .fail { |e| mark_as_failed(task, e) }
               end
@@ -47,46 +59,83 @@ module Isomorfeus
       end
 
       def get_tasks
-        @task_class.search(:state, 'ready').sort_by! { |task| task.rtime.to_i }
+        begin
+          Thread.current[:isomorfeus_user] = LocalSystem.new
+
+          result = @task_class.search(:ready).sort_by! { |task| task[:rtime] ? Time.parse(task[:rtime]).to_i : 0 }
+        ensure
+          Thread.current[:isomorfeus_user] = nil
+        end
+        result
       end
 
       def mark_as_running(task)
-        result = false
-        task = @task_class.load(key: task.key)
-        if task && (task.rtime.nil? || (task.rtime - @rtime) >= @timer_task.execution_interval) && task.state == 'ready'
-          task.state = 'running'
-          task.rtime = @rtime
-          task.save
-          result = true
+        begin
+          Thread.current[:isomorfeus_user] = LocalSystem.new
+
+          task = @task_class.load(key: task.key)
+          trt = task[:rtime] ? Time.parse(task[:rtime]) : nil
+          result = false
+          if task && (trt.nil? || (trt - @rtime) >= @timer_task.execution_interval) && task[:state] == 'ready'
+            task[:state] = 'running'
+            task[:rtime] = @rtime.to_s
+            task.save
+            result = true
+          end
+        ensure
+          Thread.current[:isomorfeus_user] = nil
         end
         result
       end
 
       def mark_as_ready(task)
-        task.state = 'ready'
+        Thread.current[:isomorfeus_user] = LocalSystem.new
+
+        task[:state] = 'ready'
         task.save
+      ensure
+        Thread.current[:isomorfeus_user] = nil
       end
 
       def mark_as_failed(task, exception)
-        task.state = 'failed'
+        Thread.current[:isomorfeus_user] = LocalSystem.new
+
+        task[:state] = 'failed'
         save_exception(task, exception)
+      ensure
+        Thread.current[:isomorfeus_user] = nil
       end
 
-      def save_exception(taks, exception)
-        task.exception = Marshal.dump(exception)
+      def save_exception(task, exception)
+        Thread.current[:isomorfeus_user] = LocalSystem.new
+
+        task[:exception] = Marshal.dump(exception)
         task.save
+      ensure
+        Thread.current[:isomorfeus_user] = nil
       end
 
       def remove_task(task)
+        Thread.current[:isomorfeus_user] = LocalSystem.new
+
         @task_class.destroy(key: task.key)
+      ensure
+        Thread.current[:isomorfeus_user] = nil
       end
 
       def cleanup
-        running_tasks = @task_class.search(:state, 'running').sort_by! { |task| task.rtime.to_i }
+        Thread.current[:isomorfeus_user] = LocalSystem.new
+
+        running_tasks = @task_class.search(:running).sort_by! do |task|
+          task[:rtime] ? Time.parse(task[:rtime]).to_i : 0
+        end
         running_tasks.each do |task|
           # previous task run has timed out most probably
-          mark_as_failed(task, RuntimeError.new('Operation execution timed out, giving up.')) if (@rtime - task.rtime) > @interval
+          trt = task[:rtime] ? Time.parse(task[:rtime]) : 0
+          mark_as_failed(task, RuntimeError.new('Operation execution timed out, giving up.')) if (@rtime - trt) > @interval
         end
+      ensure
+        Thread.current[:isomorfeus_user] = nil
       end
     end
   end

data/lib/isomorfeus/operation/version.rb

@@ -1,5 +1,5 @@
 module Isomorfeus
   module Operation
-    VERSION = '2.5.5'
+    VERSION = '22.9.0.rc2'
   end
 end

data/lib/isomorfeus-operation.rb

@@ -1,27 +1,21 @@
-require 'isomorfeus-policy'
 require 'isomorfeus-transport'
-
+require 'isomorfeus-policy'
 require 'isomorfeus/operation/config'
 require 'isomorfeus/operation/generic_class_api'
+require 'lucid_operation/gherkin'
+require 'lucid_operation/steps'
+require 'lucid_operation/promise_run'
+require 'lucid_local_operation'
+require 'lucid_simple_operation'
+require 'lucid_operation'
 
 if RUBY_ENGINE == 'opal'
-  Isomorfeus.zeitwerk.push_dir('isomorfeus_operation')
-  require_tree 'isomorfeus_operation', autoload: true
   Isomorfeus.zeitwerk.push_dir('operations')
 else
   require 'oj'
   require 'concurrent/timer_task'
   require 'isomorfeus-data'
-  require 'isomorfeus/operation/handler/operation_handler'
-  require 'isomorfeus_operation/lucid_operation/gherkin'
-  require 'isomorfeus_operation/lucid_operation/steps'
-  require 'isomorfeus_operation/lucid_operation/promise_run'
-  require 'isomorfeus_operation/lucid_local_operation/mixin'
-  require 'isomorfeus_operation/lucid_local_operation/base'
-  require 'isomorfeus_operation/lucid_simple_operation/mixin'
-  require 'isomorfeus_operation/lucid_simple_operation/base'
-  require 'isomorfeus_operation/lucid_operation/mixin'
-  require 'isomorfeus_operation/lucid_operation/base'
+  require 'isomorfeus/operation/handler'
   require 'isomorfeus/operation/deferred_task'
   require 'isomorfeus/operation/daily_task'
   require 'isomorfeus/operation/run_task'
@@ -31,6 +25,5 @@ else
   Opal.append_path(__dir__.untaint) unless IsoOpal.paths.include?(__dir__.untaint)
 
   path = File.expand_path(File.join('app', 'operations'))
-
-  Isomorfeus.zeitwerk.push_dir(path)
+  Isomorfeus.zeitwerk.push_dir(path) if Dir.exist?(path)
 end

data/lib/lucid_local_operation.rb

@@ -0,0 +1,32 @@
+class LucidLocalOperation
+  extend Preact::PropDeclarationMixin
+  extend LucidOperation::Steps
+  include LucidOperation::PromiseRun
+
+  class << self
+    if RUBY_ENGINE != 'opal'
+      def inherited(base)
+        Isomorfeus.add_valid_operation_class(base)
+      end
+    end
+
+    def promise_run(**props_hash)
+      self.new(**props_hash).promise_run
+    end
+  end
+
+  attr_reader :props
+  attr_accessor :step_result
+
+  def initialize(**props_hash)
+    @props = self.class.validated_props(props_hash)
+  end
+
+  def current_user
+    Isomorfeus.current_user
+  end
+
+  def pub_sub_client
+    Isomorfeus.pub_sub_client
+  end
+end

data/lib/{isomorfeus_operation/lucid_operation → lucid_operation}/gherkin.rb

@@ -1,4 +1,4 @@
-module LucidOperation
+class LucidOperation
   module Gherkin
     FIRST_EXCEPTION = "First must be the first one that is used and can only used once!"
     FINALLY_EXCEPTION = "Finally, except for Ensure and Failed, must be the last one to be used and can only be used once!"

data/lib/{isomorfeus_operation/lucid_operation → lucid_operation}/promise_run.rb

@@ -1,4 +1,4 @@
-module LucidOperation
+class LucidOperation
   module PromiseRun
     def promise_run
       promise = Promise.new

data/lib/{isomorfeus_operation/lucid_operation → lucid_operation}/steps.rb

@@ -1,6 +1,4 @@
-# frozen_string_literal: true
-
-module LucidOperation
+class LucidOperation
   module Steps
     def procedure(gherkin_text)
       feature_line = gherkin_text.include?('Operation: ') ? '' : "Operation: #{self.name}\n"
@@ -24,32 +22,37 @@ module LucidOperation
       @steps ||= []
     end
 
-    def First(regular_expression, &block)
+    def First(regexp_or_string, &block)
       Isomorfeus.raise_error(message: "#{self}: First already defined, can only be defined once!") if @first_defined
       @first_defined = true
-      steps << [regular_expression, block]
+      steps << [_re_from_res(regexp_or_string), block]
     end
 
-    def Given(regular_expression, &block)
-      steps << [regular_expression, block]
+    def Given(regexp_or_string, &block)
+      steps << [_re_from_res(regexp_or_string), block]
     end
     alias :And :Given
     alias :Then :Given
     alias :When :Given
 
-    def Finally(regular_expression, &block)
+    def Finally(regexp_or_string, &block)
       Isomorfeus.raise_error(message: "#{self}: Finally already defined, can only be defined once!") if @finally_defined
       @finally_defined = true
-      steps << [regular_expression, block]
+      steps << [_re_from_res(regexp_or_string), block]
+    end
+
+    def Ensure(regexp_or_string, &block)
+      ensure_steps << [_re_from_res(regexp_or_string), block]
     end
 
-    def Ensure(regular_expression, &block)
-      ensure_steps << [regular_expression, block]
+    def Failed(regexp_or_string, &block)
+      failure_steps << [_re_from_res(regexp_or_string), block]
     end
 
-    def Failed(regular_expression, &block)
-      failure_steps << [regular_expression, block]
+    def _re_from_res(regexp_or_string)
+      regexp_or_string.is_a?(String) ? Regexp.new(regexp_or_string) : regexp_or_string
     end
+
     alias :If_failing :Failed
     alias :When_failing :Failed
     alias :If_this_failed :Failed

data/lib/lucid_operation.rb

@@ -0,0 +1,49 @@
+class LucidOperation
+  extend Preact::PropDeclarationMixin
+  extend Isomorfeus::Operation::GenericClassApi
+
+  if RUBY_ENGINE == 'opal'
+    class << self
+      def procedure(gherkin_text); end
+      def steps; end
+
+      alias :gherkin :steps
+      alias :ensure_steps :steps
+      alias :failure_steps :steps
+      alias :Given :steps
+      alias :And :steps
+      alias :Then :steps
+      alias :When :steps
+      alias :Ensure :steps
+      alias :Failed :steps
+      alias :If_failing :steps
+      alias :When_failing :steps
+      alias :If_this_failed :steps
+      alias :If_that_failed :steps
+      alias :First :steps
+      alias :Finally :steps
+    end
+  else
+    extend LucidOperation::Steps
+    include LucidOperation::PromiseRun
+
+    def self.inherited(base)
+      Isomorfeus.add_valid_operation_class(base)
+    end
+
+    attr_reader :props
+    attr_accessor :step_result
+
+    def initialize(**props_hash)
+      @props = self.class.validated_props(props_hash)
+    end
+
+    def current_user
+      Isomorfeus.current_user
+    end
+
+    def pub_sub_client
+      Isomorfeus.pub_sub_client
+    end
+  end
+end

data/lib/lucid_simple_operation.rb

@@ -0,0 +1,44 @@
+class LucidSimpleOperation
+  extend Preact::PropDeclarationMixin
+  extend Isomorfeus::Operation::GenericClassApi
+
+  class << self
+    if RUBY_ENGINE == 'opal'
+      def op; end
+    else
+      def inherited(base)
+        Isomorfeus.add_valid_operation_class(base)
+      end
+
+      def op(&block)
+        @op = block
+      end
+    end
+  end
+
+  attr_reader :props
+
+  def initialize(**props_hash)
+    @props = self.class.validated_props(props_hash)
+  end
+
+  def promise_run
+    original_promise = Promise.new
+
+    operation = self
+    promise = original_promise.then do |_|
+      operation.instance_exec(&operation.class.instance_variable_get(:@op))
+    end
+
+    original_promise.resolve
+    promise
+  end
+
+  def current_user
+    Isomorfeus.current_user
+  end
+
+  def pub_sub_client
+    Isomorfeus.pub_sub_client
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isomorfeus-operation
 version: !ruby/object:Gem::Version
-  version: 2.5.5
+  version: 22.9.0.rc2
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-01 00:00:00.000000000 Z
+date: 2022-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.2
+        version: 7.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.2
+        version: 7.0.3
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -44,28 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.13.13
+        version: 3.13.21
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.13.13
+        version: 3.13.21
 - !ruby/object:Gem::Dependency
   name: opal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.5.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.5.1
 - !ruby/object:Gem::Dependency
   name: opal-activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -86,98 +86,98 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.24
+        version: 0.15.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.24
+        version: 0.15.1
 - !ruby/object:Gem::Dependency
   name: isomorfeus-data
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc2
 - !ruby/object:Gem::Dependency
   name: isomorfeus-policy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc2
 - !ruby/object:Gem::Dependency
   name: isomorfeus-preact
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 10.7.2
+        version: 22.9.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 10.7.2
+        version: 22.9.0.rc2
 - !ruby/object:Gem::Dependency
   name: isomorfeus-redux
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 22.9.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 22.9.0.rc2
 - !ruby/object:Gem::Dependency
   name: isomorfeus-transport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc2
 - !ruby/object:Gem::Dependency
   name: isomorfeus
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.5
+        version: 22.9.0.rc2
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -219,19 +219,16 @@ files:
 - lib/isomorfeus/operation/daily_task.rb
 - lib/isomorfeus/operation/deferred_task.rb
 - lib/isomorfeus/operation/generic_class_api.rb
-- lib/isomorfeus/operation/handler/operation_handler.rb
+- lib/isomorfeus/operation/handler.rb
 - lib/isomorfeus/operation/init_timer_tasks.rb
 - lib/isomorfeus/operation/run_task.rb
 - lib/isomorfeus/operation/version.rb
-- lib/isomorfeus_operation/lucid_local_operation/base.rb
-- lib/isomorfeus_operation/lucid_local_operation/mixin.rb
-- lib/isomorfeus_operation/lucid_operation/base.rb
-- lib/isomorfeus_operation/lucid_operation/gherkin.rb
-- lib/isomorfeus_operation/lucid_operation/mixin.rb
-- lib/isomorfeus_operation/lucid_operation/promise_run.rb
-- lib/isomorfeus_operation/lucid_operation/steps.rb
-- lib/isomorfeus_operation/lucid_simple_operation/base.rb
-- lib/isomorfeus_operation/lucid_simple_operation/mixin.rb
+- lib/lucid_local_operation.rb
+- lib/lucid_operation.rb
+- lib/lucid_operation/gherkin.rb
+- lib/lucid_operation/promise_run.rb
+- lib/lucid_operation/steps.rb
+- lib/lucid_simple_operation.rb
 homepage: https://isomorfeus.com
 licenses:
 - MIT
@@ -249,9 +246,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.7
 signing_key:

data/lib/isomorfeus/operation/handler/operation_handler.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module Isomorfeus
-  module Operation
-    module Handler
-      class OperationHandler < LucidHandler::Base
-        on_request do |response_agent|
-          # promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.to_s, props_hash)
-          response_agent.request.each_key do |operation_class_name|
-            if Isomorfeus.valid_operation_class_name?(operation_class_name)
-              operation_class = Isomorfeus.cached_operation_class(operation_class_name)
-              if operation_class
-                response_agent.request[operation_class_name].each_key do |method|
-                  props = response_agent.request[operation_class_name][method]
-                  props.transform_keys!(&:to_sym)
-                  begin
-                    case method
-                    when 'run'
-                      raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_run, props)
-                      operation_promise = operation_class.promise_run(**props)
-                      if operation_promise.realized?
-                        state = operation_promise.resolved? ? :resolved : :rejected
-                        result_hash = { state => operation_promise.value }
-                        if operation_promise.error
-                          e = operation_promise.error
-                          result_hash[:error] = { message: e.message, class_name: e.class.to_s, back_trace: e.backtrace }
-                        end
-                        response_agent.agent_result = { success: 'ok' , result: result_hash }
-                      else
-                        start = Time.now
-                        timeout = false
-                        while !operation_promise.realized?
-                          if (Time.now - start) > 20
-                            timeout = true
-                            break
-                          end
-                          sleep 0.01
-                        end
-                        if timeout
-                          response_agent.error = { error: 'Timeout' }
-                        else
-                          state = operation_promise.resolved? ? :resolved : :rejected
-                          result_hash = { state => operation_promise.value }
-                          if operation_promise.error
-                            e = operation_promise.error
-                            result_hash[:error] = { message: e.message, class_name: e.class.to_s, back_trace: e.backtrace }
-                          end
-                          response_agent.agent_result = { success: 'ok' , result: result_hash }
-                        end
-                      end
-                    when 'deferred'
-                      raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_deferred, props)
-                      operation_promise = operation_class.promise_deferred(**props)
-                      response_agent.agent_result = { success: 'ok' , result: { :resolved => operation_promise.value }}
-                    when 'daily'
-                      raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_daily, props)
-                      operation_promise = operation_class.promise_daily(**props)
-                      response_agent.agent_result = { success: 'ok' , result: { :resolved => operation_promise.value }}
-                    when 'remove_daily'
-                      raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_daily, props)
-                      operation_promise = operation_class.promise_remove_daily(**props)
-                      response_agent.agent_result = { success: 'ok' , result: { :resolved => operation_promise.value }}
-                    when 'daily_exist'
-                      raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_daily, props)
-                      operation_promise = operation_class.promise_daily(**props)
-                      response_agent.agent_result = { success: 'ok' , result: { :resolved => operation_promise.value }}
-                    else
-                      response_agent.error = { error: 'No such method!' }
-                    end
-                  rescue Exception => e
-                    response_agent.error = { error: { operation_class_name => "Isomorfeus::Operation::Handler::OperationHandler: #{e.message}" }}
-                  end
-                end
-              else
-                response_agent.error = { error: { operation_class_name => 'Could not get operation class!' }}
-              end
-            else
-              response_agent.error = { error: { operation_class_name => 'No such operation class!' }}
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/isomorfeus_operation/lucid_local_operation/base.rb

@@ -1,10 +0,0 @@
-module LucidLocalOperation
-  class Base 
-    def self.inherited(base)
-      base.include LucidLocalOperation::Mixin
-      if RUBY_ENGINE != 'opal'
-        Isomorfeus.add_valid_operation_class(base)
-      end
-    end
-  end
-end

data/lib/isomorfeus_operation/lucid_local_operation/mixin.rb

@@ -1,35 +0,0 @@
-module LucidLocalOperation
-  module Mixin
-    def self.included(base)
-      if RUBY_ENGINE != 'opal'
-        Isomorfeus.add_valid_operation_class(base) unless base == LucidLocalOperation::Base
-
-        def pub_sub_client
-          Isomorfeus.pub_sub_client
-        end
-      end
-
-      base.extend(LucidPropDeclaration::Mixin)
-      base.extend(LucidOperation::Steps)
-      base.include(LucidOperation::PromiseRun)
-
-      base.instance_exec do
-        def promise_run(**props_hash)
-          self.new(**props_hash).promise_run
-        end
-      end
-    end
-
-    attr_reader :props
-    attr_accessor :step_result
-
-    def initialize(**props_hash)
-      props_hash = self.class.validated_props(props_hash)
-      @props = LucidProps.new(props_hash)
-    end
-
-    def current_user
-      Isomorfeus.current_user
-    end
-  end
-end

data/lib/isomorfeus_operation/lucid_operation/base.rb

@@ -1,10 +0,0 @@
-module LucidOperation
-  class Base
-    def self.inherited(base)
-      base.include LucidOperation::Mixin
-      if RUBY_ENGINE != 'opal'
-        Isomorfeus.add_valid_operation_class(base)
-      end
-    end
-  end
-end

data/lib/isomorfeus_operation/lucid_operation/mixin.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module LucidOperation
-  module Mixin
-    def self.included(base)
-      base.extend(LucidPropDeclaration::Mixin)
-      base.extend(LucidOperation::Steps)
-      base.extend(Isomorfeus::Operation::GenericClassApi)
-
-      if RUBY_ENGINE == 'opal'
-        def procedure(gherkin_text)
-        end
-
-        def steps
-        end
-        alias :gherkin :steps
-        alias :ensure_steps :steps
-        alias :failure_steps :steps
-        alias :Given :steps
-        alias :And :steps
-        alias :Then :steps
-        alias :When :steps
-        alias :Ensure :steps
-        alias :Failed :steps
-        alias :If_failing :steps
-        alias :When_failing :steps
-        alias :If_this_failed :steps
-        alias :If_that_failed :steps
-
-        def First(regular_expression, &block)
-          Isomorfeus.raise_error(message: "#{self}: First already defined, can only be defined once!") if @first_defined
-          @first_defined = true
-        end
-
-        def Finally(regular_expression, &block)
-          Isomorfeus.raise_error(message: "#{self}: Finally already defined, can only be defined once!") if @finally_defined
-          @finally_defined = true
-        end
-      else
-        Isomorfeus.add_valid_operation_class(base) unless base == LucidOperation::Base
-        base.include(LucidOperation::PromiseRun)
-
-        attr_reader :props
-        attr_accessor :step_result
-
-        def initialize(**props_hash)
-          props_hash = self.class.validated_props(props_hash)
-          @props = LucidProps.new(props_hash)
-        end
-
-        def current_user
-          Isomorfeus.current_user
-        end
-
-        def pub_sub_client
-          Isomorfeus.pub_sub_client
-        end
-      end
-    end
-  end
-end

data/lib/isomorfeus_operation/lucid_simple_operation/base.rb

@@ -1,10 +0,0 @@
-module LucidSimpleOperation
-  class Base
-    def self.inherited(base)
-      base.include LucidSimpleOperation::Mixin
-      if RUBY_ENGINE != 'opal'
-        Isomorfeus.add_valid_operation_class(base)
-      end
-    end
-  end
-end

data/lib/isomorfeus_operation/lucid_simple_operation/mixin.rb

@@ -1,50 +0,0 @@
-module LucidSimpleOperation
-  module Mixin
-    def self.included(base)
-      base.extend(LucidPropDeclaration::Mixin)
-      base.extend(Isomorfeus::Operation::GenericClassApi)
-
-      if RUBY_ENGINE == 'opal'
-        base.instance_exec do
-          def op
-          end
-        end
-      else
-        Isomorfeus.add_valid_operation_class(base) unless base == LucidSimpleOperation::Base
-
-        base.instance_exec do
-          def op(&block)
-            @op = block
-          end
-        end
-      end
-    end
-
-    attr_reader :props
-
-    def initialize(**props_hash)
-      props_hash = self.class.validated_props(props_hash)
-      @props = LucidProps.new(props_hash)
-    end
-
-    def promise_run
-      original_promise = Promise.new
-
-      operation = self
-      promise = original_promise.then do |_|
-        operation.instance_exec(&operation.class.instance_variable_get(:@op))
-      end
-
-      original_promise.resolve
-      promise
-    end
-
-    def current_user
-      Isomorfeus.current_user
-    end
-
-    def pub_sub_client
-      Isomorfeus.pub_sub_client
-    end
-  end
-end