wip everything done except client side specs for execution_spec

catmando · catmando · commit eef30bf73e16 · 2017-02-23T18:26:38.000-05:00
diff --git a/lib/hyper-operation/api.rb b/lib/hyper-operation/api.rb
@@ -23,12 +23,12 @@ def params
       @params
     end
 
-    def abort!(*args)
-      Railway.abort!(args)
+    def abort!(arg = nil)
+      Railway.abort!(arg)
     end
 
-    def succeed!(*args)
-      Railway.succeed!(args)
+    def succeed!(arg = nil)
+      Railway.succeed!(arg)
     end
 
     def initialize
diff --git a/lib/hyper-operation/railway/params_wrapper.rb b/lib/hyper-operation/railway/params_wrapper.rb
@@ -23,8 +23,8 @@ class << self
 
         def combine_arg_array(args)
           hash = args.inject({}.with_indifferent_access) do |h, arg|
-            raise ArgumentError.new("All arguments must be hashes") unless arg.is_a?(Hash)
-            h.merge!(arg)
+            raise ArgumentError.new("All arguments must be hashes") unless arg.respond_to? :to_h
+            h.merge!(arg.to_h)
           end
         end
 
diff --git a/lib/hyper-operation/railway/run.rb b/lib/hyper-operation/railway/run.rb
@@ -1,15 +1,16 @@
 module Hyperloop
   class Operation
-    class Railway
 
-      class Exit < StandardError
-        attr_reader :state
-        attr_reader :result
-        def initialize(state, result)
-          @state = state
-          @result = result
-        end
+    class Exit < StandardError
+      attr_reader :state
+      attr_reader :result
+      def initialize(state, result)
+        @state = state
+        @result = result
       end
+    end
+
+    class Railway
 
       def tracks
         self.class.tracks
@@ -20,74 +21,97 @@ def tracks
           @tracks ||= []
         end
 
-        def to_opts(args)
-          args.first || {}
+        def to_opts(tie, args, block)
+          if args.count.zero?
+            { run: block }
+          elsif args[0].is_a?(Hash)
+            {
+              scope: args[0][:class] ? :class : args[0][:scope],
+              run: args[0][:class] || args[0][:run] || block
+            }
+          elsif args[0] == :class && block
+            { run: block, scope: :class }
+          elsif args[0].is_a?(Class) && args[0] < Operation
+            { run: proc { args[0].run(params) } }
+          else
+            scope = args[1][:scope] if args[1].is_a? Hash
+            { run: args[0], scope: scope }
+          end.merge(tie: instance_method(tie))
         end
 
-        [:step, :failed, :async].each do |meth|
-          define_method :"add_#{meth}" do |*args, &block|
-            tracks << [instance_method(meth), to_opts(args), block]
+        [:step, :failed, :async].each do |tie|
+          define_method :"add_#{tie}" do |*args, &block|
+            tracks << to_opts(tie, args, block)
           end
         end
 
-        def abort!(args)
-          raise Exit.new(:failed, args)
+        def abort!(arg)
+          raise Exit.new(:failed, arg)
         end
 
-        def succeed!(args)
-          raise Exit.new(:success, args)
+        def succeed!(arg)
+          raise Exit.new(:success, arg)
         end
       end
 
-      def step(opts, block)
+      def step(opts)
         if @last_result.is_a? Promise
           @last_result = @last_result.then do |*result|
             @last_result = result
-            apply(opts, block)
+            apply(opts, :in_promise)
           end
         elsif @state == :success
-          apply(opts, block)
+          apply(opts)
         end
       end
 
-      def failed(opts, block)
+      def failed(opts)
         if @last_result.is_a? Promise
-          @last_result = @last_result.fail do |*result|
-            @last_result = result
-            apply(opts, block)
+          @last_result = @last_result.fail do |e|
+            @last_result = e
+            apply(opts, :in_promise)
+            raise @last_result if @last_result.is_a? Exception
+            raise e
           end
         elsif @state == :failed
-          apply(opts, block)
+          apply(opts)
         end
       end
 
-      def async(opts, block)
-        apply(opts, block) if @state != :failed
+      def async(opts)
+        apply(opts) if @state != :failed
       end
 
-      def apply(opts, block)
+      def apply(opts, in_promise = nil)
         if opts[:scope] == :class
           args = [@operation, *@last_result]
           instance = @operation.class
         else
           args = @last_result
           instance = @operation
         end
+        block = opts[:run]
+        block = instance.method(block) if block.is_a? Symbol
         @last_result =
           if block.arity.zero?
-            instance.instance_eval(&block)
+            instance.instance_exec(&block)
           elsif args.is_a?(Array) && block.arity == args.count
             instance.instance_exec(*args, &block)
           else
             instance.instance_exec(args, &block)
           end
+        return @last_result unless @last_result.is_a? Promise
+        raise @last_result.error if @last_result.rejected?
+        @last_result = @last_result.value if @last_result.resolved?
+        @last_result
       rescue Exit => e
         @state = e.state
-        @last_result = e.result
+        @last_result = (e.state != :failed || e.result.is_a?(Exception)) ? e.result : e
         raise e
       rescue Exception => e
         @state = :failed
         @last_result = e
+        raise e if in_promise
       end
 
       def run
@@ -98,7 +122,7 @@ def run
         else
           @state = :success
         end
-        tracks.each { |tie, opts, block| tie.bind(self).call(opts, block) }
+        tracks.each { |opts| opts[:tie].bind(self).call(opts) }
       rescue Exit
       end
 
diff --git a/lib/hyper-operation/railway/validations.rb b/lib/hyper-operation/railway/validations.rb
@@ -45,7 +45,6 @@ def process_validations
               add_validation_error(i, "param validation #{i+1} aborted")
             end
             @state = :failed
-            @last_result = e.result unless e.result.empty?
             return # break does not work in Opal
           rescue AccessViolation => e
             add_validation_error(i, e)
diff --git a/spec/hyper-operation/execution_spec.rb b/spec/hyper-operation/execution_spec.rb
@@ -56,4 +56,157 @@ def self.promise
     end
     expect(MyOperation(i: 1).tap { MyOperation.promise.resolve(2) }.value).to eq 2
   end
+
+  it "will switch to the failure track on an error" do
+    MyOperation.class_eval do
+      def self.promise
+        @promise ||= Promise.new
+      end
+      param :i
+      step { self.class.promise }
+      step { |n| params.i + n }
+      failed { raise 'i am a' }
+      step { MyOperation.dont_call_me }
+      failed { |s| raise "#{s} failure" }
+    end
+    expect(MyOperation).not_to receive(:dont_call_me)
+    expect(MyOperation(i: 1).tap { MyOperation.promise.resolve('x') }.error.to_s).to eq 'i am a failure'
+  end
+
+  it "will begin on the failure track if there are validation errors" do
+    MyOperation.class_eval do
+      def self.promise
+        @promise ||= Promise.new
+      end
+      param :i
+      step { MyOperation.dont_call_me }
+      step { |n| params.i + n }
+      failed { |s| raise "#{s}! Looks like i am still a" }
+      step { MyOperation.dont_call_me }
+      failed { |s| "#{s} failure!" }
+    end
+    expect(MyOperation).not_to receive(:dont_call_me)
+    expect(MyOperation().tap { MyOperation.promise.resolve('x') }.error.to_s).to eq 'I is required! Looks like i am still a failure!'
+  end
+
+  it "succeed! will skip to the end" do
+    MyOperation.class_eval do
+      step { succeed! "I succeeded at last!"}
+      step { MyOperation.dont_call_me }
+      failed { MyOperation.dont_call_me}
+
+    end
+    expect(MyOperation).not_to receive(:dont_call_me)
+    expect(MyOperation().value).to eq 'I succeeded at last!'
+  end
+
+  it "succeed! will skip to the end and succeed even on the failure track" do
+    MyOperation.class_eval do
+      step { fail }
+      failed { succeed! "I still can succeed!"}
+      step { MyOperation.dont_call_me }
+      failed { MyOperation.dont_call_me}
+    end
+    expect(MyOperation).not_to receive(:dont_call_me)
+    expect(MyOperation().value).to eq 'I still can succeed!'
+    expect(MyOperation()).to be_resolved
+  end
+
+  it "abort! will skip to the end with a failure" do
+    MyOperation.class_eval do
+      step { abort! "Pride cometh before the fall!"}
+      step { MyOperation.dont_call_me }
+      failed { MyOperation.dont_call_me}
+    end
+    expect(MyOperation).not_to receive(:dont_call_me)
+    expect(MyOperation().error.result).to eq 'Pride cometh before the fall!'
+  end
+
+  it "if abort! is given an exception it will return that exception" do
+    MyOperation.class_eval do
+      step { abort! Exception.new("okay okay okay")}
+      step { MyOperation.dont_call_me }
+      failed { MyOperation.dont_call_me}
+    end
+    expect(MyOperation).not_to receive(:dont_call_me)
+    expect(MyOperation().error.to_s).to eq 'okay okay okay'
+  end
+
+  it "can chain an exception after returning" do
+    MyOperation.class_eval do
+      step { abort! Exception.new("okay okay okay")}
+      step { MyOperation.dont_call_me }
+      failed { MyOperation.dont_call_me}
+    end
+    expect(MyOperation).not_to receive(:dont_call_me)
+    expect(MyOperation().fail { |e| raise "pow" }.error.to_s).to eq 'pow'
+  end
+
+  it "can define the step, async and failed callbacks many ways" do
+    stub_const 'SayHello', Class.new(Hyperloop::Operation)
+    SayHello.class_eval do
+      param :xxx
+      step { MyOperation.say_hello if params.xxx == 123 }
+    end
+    MyOperation.class_eval do
+      param :xxx
+      def say_hello()
+        MyOperation.say_hello
+      end
+      step   { say_hello }
+      step   :say_hello
+      step   -> () { say_hello }
+      step   proc { say_hello }
+      step   SayHello # your params will be passed along to SayHello
+      async  { say_hello }
+      async  :say_hello
+      async  -> () { say_hello }
+      async  Proc.new { say_hello }
+      async  SayHello # your params will be passed along to SayHello
+      step   { fail }
+      failed { say_hello }
+      failed :say_hello
+      failed -> () { say_hello }
+      failed Proc.new { say_hello }
+      failed SayHello # your params will be passed along to SayHello
+      failed { succeed! }
+    end
+    expect(MyOperation).to receive(:say_hello).exactly(15).times
+    expect(MyOperation(xxx: 123)).to be_resolved
+  end
+
+  it "can define class level callbacks" do
+    MyOperation.class_eval do
+      step(:class) { say_hello }
+      step   class: :say_hello
+      step   class: -> () { say_hello }
+      step   class: proc { say_hello }
+      async(:class) { say_hello }
+      async  class: :say_hello
+      async  class: -> () { say_hello }
+      async  class: Proc.new { say_hello }
+      step   { fail }
+      failed(:class) { say_hello }
+      failed class: :say_hello
+      failed class: -> () { say_hello }
+      failed class: Proc.new { say_hello }
+      failed { succeed! }
+    end
+    expect(MyOperation).to receive(:say_hello).exactly(12).times
+    expect(MyOperation.run).to be_resolved
+  end
+
+  it 'can provide options different ways' do
+    MyOperation.class_eval do
+      def say_instance_hello()
+        MyOperation.say_hello
+      end
+      step(scope: :class) { say_hello }
+      step scope: :class, run: proc { say_hello }
+      step run: :say_instance_hello
+      step :say_hello, scope: :class
+    end
+    expect(MyOperation).to receive(:say_hello).exactly(4).times
+    expect(MyOperation.run).to be_resolved
+  end
 end
diff --git a/spec/test_app/development_db_name b/spec/test_app/development_db_name
