rung 0.0.1.pre.alpha → 0.1

data/features/070_operation_wrappers.feature

@@ -0,0 +1,41 @@
+# order: 70
+Feature: Operation wrappers
+:!hardbreaks:
+It is possible to define global wrappers on the Operation level using `around` call.
+
+  Scenario: Operation can have multiple global wrappers
+  Wrappers are called in the order they are defined.
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      class Wrapper
+        def initialize(name)
+          @name = name
+        end
+
+        def call
+          print_to_output "#{@name} start\n"
+          yield
+          print_to_output "#{@name} done\n"
+        end
+      end
+
+      around Wrapper.new("1")
+      around Wrapper.new("2")
+
+      step { print_to_output "Hello World!\n" }
+    end
+    """
+    When I run
+    """
+    Operation.new.call(variable: true)
+    """
+    Then I see output
+    """
+    1 start
+    2 start
+    Hello World!
+    2 done
+    1 done
+
+    """

data/features/080_exceptions_handling.feature

@@ -0,0 +1,57 @@
+# order: 80
+Feature: Exceptions handling
+Rung doesn't provide any built-in exception handling.
+If you need to catch any exceptions you can implement error catching
+using a wrapper on a desired execution level.
+
+  Scenario: All exceptions are raised
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      step { raise "Oh no!" }
+    end
+    """
+    When I run
+    """
+    begin
+      Operation.new.call(output_text: "Hello ")
+    rescue => e
+      print_to_output e.message
+    end
+    """
+    Then I see output
+    """
+    Oh no!
+    """
+
+  Scenario: Exception can be caught in a wrapper
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      class Wrapper
+        def self.call(state)
+          yield
+        rescue
+          print_to_output "Exception handled"
+          state[:exception_handled] = true
+        end
+      end
+
+      around Wrapper
+
+      step { print_to_output "Hello World!\n"; raise "oops!" }
+    end
+    """
+    When I run
+    """
+    @result = Operation.new.call
+    """
+    Then I see output
+    """
+    Hello World!
+    Exception handled
+    """
+    And I can assure that
+    """
+    @result.to_h == { exception_handled: true }
+    """

data/features/090_around_step_wrapper.feature

@@ -0,0 +1,130 @@
+# order: 90
+Feature: Around step wrapper
+:!hardbreaks:
+
+  Scenario: Step wrapper is called for every step
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      class Counter
+        def initialize
+          @count = 0
+        end
+
+        def call
+          @count += 1
+          print_to_output "Step #{@count}\n"
+          yield
+        end
+      end
+
+      around_each Counter.new
+
+      step do
+        print_to_output "Hello\n"
+      end
+
+      step do
+        print_to_output "World\n"
+      end
+    end
+    """
+    When I run
+    """
+    Operation.new.call
+    """
+    Then I see output
+    """
+    Step 1
+    Hello
+    Step 2
+    World
+
+    """
+
+  Scenario: Step wrapper receives state and current step
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      class Logger
+        def self.call(state, step)
+          result = yield
+
+          print_to_output "State: #{state.to_h}, success: #{state.success?}," \
+            "ignores result: #{step.ignore_result?}, nested: #{step.nested?}, result: #{result}\n"
+
+          result
+        end
+      end
+
+      noop_wrapper = -> (&block) { block.call }
+
+      around_each Logger
+
+      step do |state|
+        print_to_output "Hello\n"
+        state[:test] = 42
+      end
+
+      step noop_wrapper do
+        tee do |state|
+          state[:test] = 5
+          print_to_output "World\n"
+          true
+        end
+      end
+    end
+    """
+    When I run
+    """
+    Operation.new.call
+    """
+    Then I see output
+    """
+    Hello
+    State: {:test=>42}, success: true,ignores result: false, nested: false, result: 42
+    World
+    State: {:test=>5}, success: true,ignores result: true, nested: false, result: true
+    State: {:test=>5}, success: true,ignores result: false, nested: true, result: true
+
+    """
+
+  Scenario: Step wrapper returned result is treated as the step result
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      class Boom
+        def self.call(state)
+          yield
+          print_to_output "Boom!\n"
+          false # always return false
+        end
+      end
+
+      around_each Boom
+
+      tee do |state| # tee step ignores result, so Boom doesn't affect it
+        print_to_output "Hello\n"
+      end
+
+      step { print_to_output "Beautiful\n" }
+      step { print_to_output "World\n" }
+    end
+    """
+    When I run
+    """
+    @result = Operation.new.call
+    """
+    Then I see output
+    """
+    Hello
+    Boom!
+    Beautiful
+    Boom!
+
+    """
+    And I can assure that
+    """
+    @result.success? == false
+    """
+

data/features/200_misc.feature

@@ -0,0 +1,18 @@
+# order: 200
+Feature: Misc
+  Scenario: Operation defines .call shorthand class method
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      step {|state| state[:test] = 42 + state[:input] }
+    end
+    """
+    When I run
+    """
+    @result1 = Operation.call(input: 1)
+    @result2 = Operation.new.call(input: 1)
+    """
+    And I can assure that
+    """
+    @result1.to_h == @result2.to_h
+    """

data/features/step_definitions/output.rb

@@ -1,10 +1,15 @@
 Before do
-  allow_any_instance_of(Object).to receive(:print_to_output) do |_receiver, output|
-    @stored_output ||= ""
+  allow_any_instance_of(Object)
+    .to receive(:print_to_output) do |_receiver, output|
+    @stored_output ||= ''
     @stored_output << output
   end
 end
 
-Then("I see output") do |string|
+Then('I see output') do |string|
   expect(@stored_output).to eq string
 end
+
+Then('I clear output') do
+  @stored_output = ''
+end

data/features/step_definitions/temporary_code_scope.rb

@@ -1,16 +1,17 @@
-class TemporaryScope
-end
-
-Given("definition") do |content|
-  @temporary_scope ||= TemporaryScope.new
+Given('definition') do |content|
+  @temporary_scope ||= Object.new
 
   @temporary_scope.instance_eval(content)
 end
 
-When("I run") do |content|
+When('I run') do |content|
   @temporary_scope.instance_eval(content)
 end
 
-Then("I can assure that") do |content|
+Then(/^I can assure that/) do |content|
   expect(@temporary_scope.instance_eval(content)).to eq true
 end
+
+Then('I can test that') do |content|
+  @temporary_scope.instance_eval(content)
+end

data/lib/rung.rb

@@ -2,17 +2,18 @@ require 'forwardable'
 
 require 'rung/version'
 require 'rung/error'
+require 'rung/value_object'
 
-require 'rung/definition/steps/step'
-require 'rung/definition/steps/nested_step'
+require 'rung/definition/step'
+require 'rung/definition/callback'
+require 'rung/definition/nested_step'
 
-require 'rung/definition/steps_definition'
+require 'rung/definition/operation_dsl'
 require 'rung/definition/steps_dsl'
 
-require 'rung/runner/result'
+require 'rung/state'
 require 'rung/runner/run_context'
-require 'rung/runner/run_state'
 require 'rung/runner/call_helper'
 require 'rung/runner/runner'
 
-require 'rung/base'
+require 'rung/operation'

data/lib/rung/definition/callback.rb

@@ -0,0 +1,14 @@
+module Rung
+  module Definition
+    class Callback
+      include ValueObject
+
+      def initialize(action = nil, from_block: false)
+        @action = action
+        @from_block = from_block
+      end
+
+      attr_reader :action, :from_block
+    end
+  end
+end

data/lib/rung/definition/nested_step.rb

@@ -0,0 +1,16 @@
+module Rung
+  module Definition
+    class NestedStep < Step
+      def initialize(action, nested_steps, options = {})
+        super(action, options)
+        @nested_steps = nested_steps
+      end
+
+      attr_reader :nested_steps
+
+      def nested?
+        true
+      end
+    end
+  end
+end

data/lib/rung/definition/operation_dsl.rb

@@ -0,0 +1,31 @@
+module Rung
+  module Definition
+    module OperationDSL
+      def around_callbacks
+        @around_callbacks ||= []
+      end
+
+      def around_each_callbacks
+        @around_each_callbacks ||= []
+      end
+
+      def around(action = nil, &block)
+        around_callbacks.push callback_from_definition(action, &block)
+      end
+
+      def around_each(action = nil, &block)
+        around_each_callbacks.push callback_from_definition(action, &block)
+      end
+
+      private
+
+      def callback_from_definition(action, &block)
+        if block
+          Callback.new block, from_block: true
+        else
+          Callback.new action
+        end
+      end
+    end
+  end
+end

data/lib/rung/definition/step.rb

@@ -0,0 +1,43 @@
+module Rung
+  module Definition
+    class Step
+      include ValueObject
+      # rubocop:disable Metrics/LineLength
+      def initialize(action, from_block: false, run_on: :success, ignore_result: false, fail_fast: false)
+        # rubocop:enable Metrics/LineLength
+        @action = action
+        @from_block = from_block
+        @run_on = run_on
+        @ignore_result = ignore_result
+        @fail_fast = fail_fast
+      end
+
+      attr_reader :action, :from_block
+
+      def run?(success)
+        case @run_on
+        when :success
+          success
+        when :failure
+          !success
+        when :any
+          true
+        else
+          false
+        end
+      end
+
+      def nested?
+        false
+      end
+
+      def ignore_result?
+        @ignore_result
+      end
+
+      def fail_fast?
+        @fail_fast
+      end
+    end
+  end
+end

data/lib/rung/definition/steps_dsl.rb

@@ -2,35 +2,50 @@ module Rung
   module Definition
     module StepsDSL
       def steps_definition
-        @steps_definition ||= StepsDefinition.new
+        @steps_definition ||= []
       end
 
-      def step(reference = nil, &block)
-        add_step(reference, &block)
+      def add_generic_step(action, options = {}, &block)
+        step = step_from_definition action, **options, &block
+        steps_definition.push step
       end
 
-      def failure(reference = nil, &block)
-        add_step(reference, run_on: :failure, &block)
+      def step(*args, &block)
+        add_step_from_args args, &block
       end
 
-      def wrap(wrapper, &block)
-        nested_steps = calculate_block_nested_steps(&block)
-        add_nested_step wrapper, nested_steps
+      def tee(*args, &block)
+        add_step_from_args args, ignore_result: true, &block
+      end
+
+      def failure(*args, &block)
+        add_step_from_args args, run_on: :failure, ignore_result: true, &block
+      end
+
+      def always(*args, &block)
+        add_step_from_args args, run_on: :any, ignore_result: true, &block
       end
 
       private
 
-      def add_step(reference, options = {}, &block)
-        step = if block
-          Step.new(block, *options, from_block: true)
-        else
-          Step.new(reference, options)
-        end
-        steps_definition.push(step)
+      def add_step_from_args(args, options = {}, &block)
+        action, action_options = extract_action_and_options!(args)
+        add_generic_step action, **options, **action_options, &block
+      end
+
+      def extract_action_and_options!(args)
+        options = args.last.is_a?(::Hash) ? args.pop : {}
+        [args.first, options]
       end
 
-      def add_nested_step(operation, nested_steps)
-        steps_definition.push(NestedStep.new(operation, nested_steps))
+      def step_from_definition(action, options, &block)
+        if action && block
+          NestedStep.new(action, calculate_block_nested_steps(&block), options)
+        elsif block
+          Step.new(block, **options, from_block: true)
+        else
+          Step.new(action, options)
+        end
       end
 
       def calculate_block_nested_steps(&block)
@@ -42,7 +57,7 @@ module Rung
 
       def with_new_steps_definition
         old_steps_definition = @steps_definition
-        @steps_definition = StepsDefinition.new
+        @steps_definition = []
         yield
       ensure
         @steps_definition = old_steps_definition