isomorfeus-operation 1.0.0.zeta25 → 2.0.0.rc1

data/lib/isomorfeus_operation/lucid_operation/mixin.rb

@@ -1,95 +1,95 @@
-# frozen_string_literal: true
-
-module LucidOperation
-  module Mixin
-    def self.included(base)
-      base.extend(LucidPropDeclaration::Mixin)
-
-      if RUBY_ENGINE == 'opal'
-        base.instance_exec do
-          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
-
-          def promise_run(**props_hash)
-            props = validated_props(props_hash)
-            Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, props).then do |agent|
-              unless agent.processed
-                agent.processed = true
-                if agent.response.key?(:error)
-                  Isomorfeus.raise_error(message: agent.response[:error])
-                end
-                agent.result = agent.response[:result]
-              end
-              if agent.result.key?(:rejected)
-                if agent.result.key?(:error)
-                  e = agent.result[:error]
-                  exception_class_name = e[:class_name]
-                  exception_class = exception_class_name.constantize
-                  exception = exception_class.new(e[:message])
-                  exception.set_backtrace(e[:backtrace])
-                  raise exception
-                else
-                  raise agent.result[:rejected]
-                end
-              else
-                agent.result[:resolved]
-              end
-            end
-          end
-        end
-      else
-        Isomorfeus.add_valid_operation_class(base) unless base == LucidOperation::Base
-        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
-
-        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
+# frozen_string_literal: true
+
+module LucidOperation
+  module Mixin
+    def self.included(base)
+      base.extend(LucidPropDeclaration::Mixin)
+
+      if RUBY_ENGINE == 'opal'
+        base.instance_exec do
+          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
+
+          def promise_run(**props_hash)
+            props = validated_props(props_hash)
+            Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, props).then do |agent|
+              unless agent.processed
+                agent.processed = true
+                if agent.response.key?(:error)
+                  Isomorfeus.raise_error(message: agent.response[:error])
+                end
+                agent.result = agent.response[:result]
+              end
+              if agent.result.key?(:rejected)
+                if agent.result.key?(:error)
+                  e = agent.result[:error]
+                  exception_class_name = e[:class_name]
+                  exception_class = exception_class_name.constantize
+                  exception = exception_class.new(e[:message])
+                  exception.set_backtrace(e[:backtrace])
+                  raise exception
+                else
+                  raise agent.result[:rejected]
+                end
+              else
+                agent.result[:resolved]
+              end
+            end
+          end
+        end
+      else
+        Isomorfeus.add_valid_operation_class(base) unless base == LucidOperation::Base
+        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
+
+        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_operation/promise_run.rb

@@ -1,67 +1,67 @@
-module LucidOperation
-  module PromiseRun
-    def promise_run
-      promise = Promise.new
-      original_promise = promise
-      operation = self
-
-      # steps
-      self.class.gherkin[:steps].each do |gherkin_step|
-        matched = false
-        self.class.steps.each do |step|
-          # step[0] -> regular_expression
-          # step[1] -> block
-          match_data = gherkin_step.match(step[0])
-          if match_data
-            matched = true
-            promise = promise.then do |result|
-              operation.step_result = result
-              operation.instance_exec(*match_data, &step[1])
-            end
-          end
-        end
-        Isomorfeus.raise_error(message: "No match found for step #{gherkin_step}!") unless matched
-      end
-
-      # fail track
-      self.class.gherkin[:failure].each do |gherkin_step|
-        matched = false
-        self.class.failure_steps.each do |step|
-          # step[0] -> regular_expression
-          # step[1] -> block
-          match_data = gherkin_step.match(step[0])
-          if match_data
-            matched = true
-            promise = promise.fail do |result|
-              operation.step_result = result
-              operation.instance_exec(*match_data, &step[1])
-            end
-          end
-        end
-        Isomorfeus.raise_error(message: "No match found for failure step #{gherkin_step}!") unless matched
-      end
-
-      # ensure
-      self.class.gherkin[:ensure].each do |gherkin_step|
-        matched = false
-        self.class.ensure_steps.each do |step|
-          # step[0] -> regular_expression
-          # step[1] -> block
-          match_data = gherkin_step.match(step[0])
-          if match_data
-            matched = true
-
-            promise = promise.ensure do |result|
-              operation.step_result = result
-              operation.instance_exec(*match_data, &step[1])
-            end
-          end
-        end
-        Isomorfeus.raise_error(message: "No match found for ensure step #{gherkin_step}!") unless matched
-      end
-
-      original_promise.resolve
-      promise
-    end
-  end
-end
+module LucidOperation
+  module PromiseRun
+    def promise_run
+      promise = Promise.new
+      original_promise = promise
+      operation = self
+
+      # steps
+      self.class.gherkin[:steps].each do |gherkin_step|
+        matched = false
+        self.class.steps.each do |step|
+          # step[0] -> regular_expression
+          # step[1] -> block
+          match_data = gherkin_step.match(step[0])
+          if match_data
+            matched = true
+            promise = promise.then do |result|
+              operation.step_result = result
+              operation.instance_exec(*match_data, &step[1])
+            end
+          end
+        end
+        Isomorfeus.raise_error(message: "No match found for step #{gherkin_step}!") unless matched
+      end
+
+      # fail track
+      self.class.gherkin[:failure].each do |gherkin_step|
+        matched = false
+        self.class.failure_steps.each do |step|
+          # step[0] -> regular_expression
+          # step[1] -> block
+          match_data = gherkin_step.match(step[0])
+          if match_data
+            matched = true
+            promise = promise.fail do |result|
+              operation.step_result = result
+              operation.instance_exec(*match_data, &step[1])
+            end
+          end
+        end
+        Isomorfeus.raise_error(message: "No match found for failure step #{gherkin_step}!") unless matched
+      end
+
+      # ensure
+      self.class.gherkin[:ensure].each do |gherkin_step|
+        matched = false
+        self.class.ensure_steps.each do |step|
+          # step[0] -> regular_expression
+          # step[1] -> block
+          match_data = gherkin_step.match(step[0])
+          if match_data
+            matched = true
+
+            promise = promise.ensure do |result|
+              operation.step_result = result
+              operation.instance_exec(*match_data, &step[1])
+            end
+          end
+        end
+        Isomorfeus.raise_error(message: "No match found for ensure step #{gherkin_step}!") unless matched
+      end
+
+      original_promise.resolve
+      promise
+    end
+  end
+end

data/lib/isomorfeus_operation/lucid_operation/steps.rb

@@ -1,58 +1,58 @@
-# frozen_string_literal: true
-
-module LucidOperation
-  module Steps
-    def procedure(gherkin_text)
-      feature_line = gherkin_text.include?('Operation: ') ? '' : "Operation: #{self.name}\n"
-      scenario_line = feature_line == '' || gherkin_text.include?('Procedure: ') ? '' : "  Procedure: #{self.name} executing\n"
-      @procedure = feature_line + scenario_line + gherkin_text
-    end
-
-    def gherkin
-      @gherkin ||= LucidOperation::Gherkin.parse(@procedure)
-    end
-
-    def ensure_steps
-      @ensure_steps ||= []
-    end
-
-    def failure_steps
-      @failure_steps ||= []
-    end
-
-    def steps
-      @steps ||= []
-    end
-
-    def First(regular_expression, &block)
-      Isomorfeus.raise_error(message: "#{self}: First already defined, can only be defined once!") if @first_defined
-      @first_defined = true
-      steps << [regular_expression, block]
-    end
-
-    def Given(regular_expression, &block)
-      steps << [regular_expression, block]
-    end
-    alias :And :Given
-    alias :Then :Given
-    alias :When :Given
-
-    def Finally(regular_expression, &block)
-      Isomorfeus.raise_error(message: "#{self}: Finally already defined, can only be defined once!") if @finally_defined
-      @finally_defined = true
-      steps << [regular_expression, block]
-    end
-
-    def Ensure(regular_expression, &block)
-      ensure_steps << [regular_expression, block]
-    end
-
-    def Failed(regular_expression, &block)
-      failure_steps << [regular_expression, block]
-    end
-    alias :If_failing :Failed
-    alias :When_failing :Failed
-    alias :If_this_failed :Failed
-    alias :If_that_failed :Failed
-  end
-end
+# frozen_string_literal: true
+
+module LucidOperation
+  module Steps
+    def procedure(gherkin_text)
+      feature_line = gherkin_text.include?('Operation: ') ? '' : "Operation: #{self.name}\n"
+      scenario_line = feature_line == '' || gherkin_text.include?('Procedure: ') ? '' : "  Procedure: #{self.name} executing\n"
+      @procedure = feature_line + scenario_line + gherkin_text
+    end
+
+    def gherkin
+      @gherkin ||= LucidOperation::Gherkin.parse(@procedure)
+    end
+
+    def ensure_steps
+      @ensure_steps ||= []
+    end
+
+    def failure_steps
+      @failure_steps ||= []
+    end
+
+    def steps
+      @steps ||= []
+    end
+
+    def First(regular_expression, &block)
+      Isomorfeus.raise_error(message: "#{self}: First already defined, can only be defined once!") if @first_defined
+      @first_defined = true
+      steps << [regular_expression, block]
+    end
+
+    def Given(regular_expression, &block)
+      steps << [regular_expression, block]
+    end
+    alias :And :Given
+    alias :Then :Given
+    alias :When :Given
+
+    def Finally(regular_expression, &block)
+      Isomorfeus.raise_error(message: "#{self}: Finally already defined, can only be defined once!") if @finally_defined
+      @finally_defined = true
+      steps << [regular_expression, block]
+    end
+
+    def Ensure(regular_expression, &block)
+      ensure_steps << [regular_expression, block]
+    end
+
+    def Failed(regular_expression, &block)
+      failure_steps << [regular_expression, block]
+    end
+    alias :If_failing :Failed
+    alias :When_failing :Failed
+    alias :If_this_failed :Failed
+    alias :If_that_failed :Failed
+  end
+end

data/lib/isomorfeus_operation/lucid_quick_op/base.rb

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

data/lib/isomorfeus_operation/lucid_quick_op/mixin.rb

@@ -1,80 +1,80 @@
-module LucidQuickOp
-  module Mixin
-    def self.included(base)
-      base.extend(LucidPropDeclaration::Mixin)
-
-      if RUBY_ENGINE == 'opal'
-        base.instance_exec do
-          def op
-          end
-
-          def promise_run(**props_hash)
-            props = validated_props(props_hash)
-            Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, props).then do |agent|
-              unless agent.processed
-                agent.processed = true
-                if agent.response.key?(:error)
-                  Isomorfeus.raise_error(message: agent.response[:error])
-                end
-                agent.result = agent.response[:result]
-              end
-              if agent.result.key?(:rejected)
-                if agent.result.key?(:error)
-                  e = agent.result[:error]
-                  exception_class_name = e[:class_name]
-                  exception_class = exception_class_name.constantize
-                  exception = exception_class.new(e[:message])
-                  exception.set_backtrace(e[:backtrace])
-                  raise exception
-                else
-                  raise agent.result[:rejected]
-                end
-              else
-                agent.result[:resolved]
-              end
-            end
-          end
-        end
-      else
-        Isomorfeus.add_valid_operation_class(base) unless base == LucidQuickOp::Base
-
-        base.instance_exec do
-          def op(&block)
-            @op = block
-          end
-
-          def promise_run(**props_hash)
-            self.new(**props_hash).promise_run
-          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
+module LucidQuickOp
+  module Mixin
+    def self.included(base)
+      base.extend(LucidPropDeclaration::Mixin)
+
+      if RUBY_ENGINE == 'opal'
+        base.instance_exec do
+          def op
+          end
+
+          def promise_run(**props_hash)
+            props = validated_props(props_hash)
+            Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, props).then do |agent|
+              unless agent.processed
+                agent.processed = true
+                if agent.response.key?(:error)
+                  Isomorfeus.raise_error(message: agent.response[:error])
+                end
+                agent.result = agent.response[:result]
+              end
+              if agent.result.key?(:rejected)
+                if agent.result.key?(:error)
+                  e = agent.result[:error]
+                  exception_class_name = e[:class_name]
+                  exception_class = exception_class_name.constantize
+                  exception = exception_class.new(e[:message])
+                  exception.set_backtrace(e[:backtrace])
+                  raise exception
+                else
+                  raise agent.result[:rejected]
+                end
+              else
+                agent.result[:resolved]
+              end
+            end
+          end
+        end
+      else
+        Isomorfeus.add_valid_operation_class(base) unless base == LucidQuickOp::Base
+
+        base.instance_exec do
+          def op(&block)
+            @op = block
+          end
+
+          def promise_run(**props_hash)
+            self.new(**props_hash).promise_run
+          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