steppy 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a3e69bd0bf6da2bc6ad68601777f7aaf6c350afabf6f899db8dcb244ea9ebcf
-  data.tar.gz: c2e3b695f6f791c3c90c523c357915071fe0a5cff19151d10ca4bed3b795e3b0
+  metadata.gz: a9fa807ba5d30abc006adf68842988e5fb4fb48a77407fc3b34ba92494a375ba
+  data.tar.gz: 79da4b077d8c45dcd60486831bd29242446533cb7d7f3a9b32d351ef47683d88
 SHA512:
-  metadata.gz: c694feb7e483edbee03a84d936f5d64295911c318232ec31ea6f7ba9b58068d199cec2df97e1f9f14284387dd01c0e0c56b20f18e7c61d63ddfcac668110dbb0
-  data.tar.gz: 4865f642107ed0cfd33d1c5ac2200cdeef40adc71407e73f9cd349f33994c556fcc65f44556faa66b7000a7c3a199496bfed05297087b05bb305fa97692854e3
+  metadata.gz: d080019e5966955f4278671c4ec3400268048781c4c3b7c2e2b67fea2fbe3e8c953583f0848cb3c7a2f7eb086b8d99c72d6f3042e0c7cadaafb6e55743796db3
+  data.tar.gz: b3466168ec557ce684a226b1bc516f54736dc2d9f80d062ee599199e943b637dfa2921f20b849a52d2265edc3ee8578f7279b9e5cf8438816d7479a17d655cf8

data/.rubocop.yml

@@ -22,3 +22,6 @@ Airbnb/ClassOrModuleDeclaredInWrongFile:
 
 Airbnb/ModuleMethodInWrongFile:
   Enabled: false
+
+Lint/EndAlignment:
+  EnforcedStyleAlignWith: variable

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steppy (0.6.0)
+    steppy (0.7.0)
 
 GEM
   remote: https://rubygems.org/
@@ -24,12 +24,12 @@ GEM
     json (2.1.0)
     minitest (5.11.3)
     parallel (1.12.1)
-    parser (2.5.1.0)
+    parser (2.5.1.2)
       ast (~> 2.4.0)
-    powerpack (0.1.1)
+    powerpack (0.1.2)
     rainbow (3.0.0)
     rake (10.5.0)
-    reek (4.8.1)
+    reek (4.8.2)
       codeclimate-engine-rb (~> 0.4.0)
       parser (>= 2.5.0.0, < 2.6)
       rainbow (>= 2.0, < 4.0)
@@ -45,14 +45,14 @@ GEM
       rubocop-rspec (= 1.22.1)
     rubocop-rspec (1.22.1)
       rubocop (>= 0.52.1)
-    ruby-progressbar (1.9.0)
+    ruby-progressbar (1.10.0)
     simplecov (0.16.1)
       docile (~> 1.1)
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.2)
     thread_safe (0.3.6)
-    unicode-display_width (1.3.2)
+    unicode-display_width (1.4.0)
     virtus (1.0.5)
       axiom-types (~> 0.1)
       coercible (~> 1.0)

data/lib/steppy.rb

@@ -11,178 +11,200 @@ module Steppy
     base.include InstanceMethods
   end
 
-  # Steppy class methods that will be added to your included classes.
-  module ClassMethods
-    if !defined? step
-      def step(method, **args, &block)
-        args[:prefix] ||= :step
-
-        steppy_add(
-          step_method: method,
-          step_args: args,
-          step_block: block,
-        )
-      end
+  # :reek:TooManyStatements
+  def self.parse_step(method:, args:, block:)
+    if args.key?(:if)
+      args[:condition] = args.delete(:if)
     end
 
-    if !defined? step_if
-      def step_if(condition, &block)
-        steppy_add step_if: condition, step_block: block
-      end
+    if args.key?(:unless)
+      args[:condition] = -> { !steppy_run_condition(args.delete(:unless)) }
     end
 
-    if !defined? step_unless
-      def step_unless(condition, &block)
-        steppy_add(
-          step_if: -> { !steppy_run_block(condition) },
-          step_block: block,
-        )
-      end
+    if method.is_a?(Proc)
+      block = method
+      method = nil
     end
 
-    if !defined? step_set
-      def step_set(*sets)
-        steppy_cache[:sets] = *sets
-      end
+    { method: method, args: args, block: block }
+  end
+
+  # Steppy class methods that will be added to your included classes.
+  module ClassMethods
+    def steppy(&block)
+      steppy_cache[:block] = block
     end
 
-    def steppy_cache
-      @steppy_cache ||= SteppyCache.new(steps: nil, sets: [], block: nil)
+    def step_set(*sets)
+      steppy_cache[:sets] += sets
     end
 
-    def steppy_steps
-      steppy_cache[:steps] ||= []
+    def step(method = nil, args = {}, &block) # rubocop:disable Airbnb/OptArgParameters
+      steppy_cache[:steps].push(
+        Steppy.parse_step({ method: method, args: args, block: block })
+      )
+      self
     end
+    alias stepy_return step
 
-    def steppy_add(step)
-      steppy_steps.push(step)
-      steppy_cache
+    def step_if(condition, &block)
+      steppy_cache[:steps].push(condition: condition, block: block)
+      self
     end
 
-    def steppy(&block)
-      steppy_cache[:block] = block
+    def step_unless(condition, &block)
+      steppy_cache[:steps].push(condition: -> { !steppy_run_condition(condition) }, block: block)
+      self
+    end
+
+    def step_rescue(exceptions = nil, &block) # rubocop:disable Airbnb/OptArgParameters
+      steppy_cache[:rescues].push(exceptions: exceptions, block: block)
+      self
+    end
+
+    def steppy_cache
+      @steppy_cache ||= SteppyCache.new(steps: [], sets: [], rescues: [])
     end
   end
 
   # Steppy instance methods that will be added.
   module InstanceMethods
-    def steppy(attributes, prefix: :step)
-      @steppy_prefix = prefix
-      @steppy = { attributes: attributes.freeze }
+    attr_reader :steppy_cache
 
-      steppy_run(
-        (steppy_class_block || steppy_class_cache).to_h
-      )
-    end
+    def steppy(attributes, cache = {})
+      steppy_initialize_cache({ attributes: attributes, prefix: :step }.merge(cache))
 
-    def steppy_attributes
-      @steppy[:attributes]
+      if steppy_cache.key?(:block)
+        instance_exec(&steppy_cache[:block])
+      else
+        steppy_run(steppy_cache)
+      end
+    rescue => exception
+      steppy_rescue exception, steppy_cache[:rescues]
     end
 
-    protected
+    def step_set(*sets)
+      steppy_sets(sets)
+    end
 
-    def steppy_run(steps:, sets:, **)
-      steppy_run_sets(sets)
-      steppy_run_steps(steps)
+    def step(method = nil, args = {}, &block) # rubocop:disable Airbnb/OptArgParameters
+      steppy_run_step Steppy.parse_step({ method: method, args: args, block: block })
+    end
+    alias stepy_return step
 
-      @steppy[:result] || nil
+    def step_if(condition, &block)
+      steppy_run_condition_block condition, block
     end
 
-    def steppy_class_block
-      block = steppy_class_cache[:block]
-      block && steppy_class.instance_exec(&block)
+    def step_unless(condition, &block)
+      steppy_run_condition_block -> { !steppy_run_condition(condition) }, block
     end
 
-    def steppy_class_cache
-      self.class.steppy_cache
+    def step_rescue(*)
+      raise '#step_rescue can not be used in a block, please just add rescue to the #steppy block.'
     end
 
-    def steppy_run_sets(sets)
-      sets ||= steppy_class_cache[:sets]
+    protected
 
-      sets.each do |set|
-        steppy_set(set, steppy_attributes[set])
-      end
+    def steppy_run(steps:, sets:, **)
+      steppy_sets(sets)
+      steppy_steps(steps)
     end
 
-    def steppy_run_step(step)
-      step_method = step[:step_method]
+    def steppy_sets(sets)
+      sets.each { |key, value| steppy_set(key, value || steppy_attributes[key]) }
+    end
 
-      if step.key?(:step_if)
-        steppy_if_block(step)
-      elsif step_method.is_a? Proc
-        steppy_run_block(step_method)
-      else
-        steppy_step(step)
-      end
+    def steppy_set(key, value)
+      key && instance_variable_set("@#{key}", value)
     end
 
-    def steppy_run_steps(steps)
-      return if !steps
+    def steppy_steps(steps)
+      steps.each do |step|
+        condition = step[:condition]
 
-      steps.each { |step| @steppy[:result] = steppy_run_step(step) }
+        steppy_cache[:result] = if condition
+          steppy_run_condition_block(condition, step[:block])
+        else
+          steppy_run_step(step)
+        end
+      end
+
+      steppy_result
     end
 
-    def steppy_step(step_method:, step_args:, step_block:)
-      if steppy_if(step_args[:if]) || @steppy_prefix != step_args[:prefix]
-        return
+    def steppy_rescue(exception, rescues)
+      exception_class = exception.class
+
+      if exception_class == SteppyError || rescues.empty?
+        raise exception
       end
 
-      method_name = "#{@steppy_prefix}_#{step_method}"
+      rescues.each do |exceptions:, block:|
+        if !exceptions || (exceptions && !exceptions.include?(exception_class))
+          steppy_cache[:result] = instance_exec(steppy_attributes, &block)
+        end
+      end
 
-      result = if step_block
-                 steppy_run_block(step_block)
-               else
-                 steppy_run_method(method_name)
-               end
+      steppy_result
+    end
 
-      steppy_set(step_args[:set], result)
+    def steppy_run_condition_block(condition, block)
+      if steppy_run_condition(condition)
+        steppy_run(steppy_cache_from_block(block))
+      end
     end
 
-    def steppy_run_method(method_name)
-      if method(method_name).arity > 0
-        public_send(method_name, steppy_attributes)
+    def steppy_run_condition(condition)
+      return true unless condition
+
+      if condition.arity > 0
+        instance_exec(steppy_attributes, &condition)
       else
-        public_send(method_name)
+        instance_exec(&condition)
       end
     end
 
-    def steppy_run_block(step_block)
-      if step_block.arity > 0
-        instance_exec(steppy_attributes, &step_block)
+    def steppy_run_step(method:, args:, block:)
+      return unless steppy_run_condition(args[:condition])
+
+      result = if block
+        instance_exec(steppy_attributes, &block)
       else
-        instance_exec(&step_block)
+        steppy_run_method(method, steppy_attributes)
       end
+
+      steppy_set(args[:set], result)
+
+      result
     end
 
-    def steppy_if(step_if)
-      return unless step_if
+    def steppy_run_method(method_name, attributes)
+      method = "#{steppy_cache[:prefix]}_#{method_name}"
 
-      if step_if.arity > 0
-        !instance_exec(steppy_attributes, &step_if)
+      if method(method).arity > 0
+        public_send(method, attributes)
       else
-        !instance_exec(&step_if)
+        public_send(method)
       end
     end
 
-    def steppy_set(step_set, result)
-      step_set && instance_variable_set("@#{step_set}", result)
-
-      result
+    def steppy_cache_from_block(block)
+      Class.new { include Steppy }.instance_exec(&block).steppy_cache
     end
 
-    def steppy_if_block(step_if:, step_block:)
-      passed = if step_if.arity > 0
-                 instance_exec(steppy_attributes, &step_if)
-               else
-                 instance_exec(&step_if)
-               end
+    def steppy_initialize_cache(cache)
+      @steppy_cache = SteppyCache.new(
+        self.class.steppy_cache.to_h.merge(result: nil).merge(cache)
+      )
+    end
 
-      passed && steppy_run(steppy_class.instance_exec(&step_block).to_h)
+    def steppy_attributes
+      steppy_cache[:attributes]
     end
 
-    def steppy_class
-      Class.new { include Steppy }
+    def steppy_result
+      steppy_cache[:result]
     end
   end
 end

data/lib/steppy/cache.rb

@@ -24,5 +24,9 @@ module Steppy
     def to_h
       @mutex.synchronize { @hash }
     end
+
+    def method_missing(method, *args, &block)
+      @mutex.synchronize { @hash.public_send(method, *args, &block) }
+    end
   end
 end

data/lib/steppy/error.rb

@@ -2,13 +2,13 @@
 
 # Incase you need to throw an error related to steppy
 class SteppyError < StandardError
-  attr_reader :step
+  attr_reader :steppy
   # rubocop:disable Airbnb/OptArgParameters
-  def initialize(step = nil)
+  def initialize(steppy = nil)
     # rubocop:enable Airbnb/OptArgParameters
-    if step
-      @step = step
-      message = step.to_json
+    if steppy
+      @steppy = steppy
+      message = steppy.is_a?(String) ? steppy : steppy.to_json
     end
 
     super(message)

data/lib/steppy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Steppy
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steppy
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - cj
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-13 00:00:00.000000000 Z
+date: 2018-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler