steppy 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 987fb5fa5cd7883b0604fb5c0d29ca5bb955d4d34f9d53e21406ab78fbb5f40c
-  data.tar.gz: c9f3778df2fd3edaf6a2b3daa12cf69deb35f876eecc8911ceebe8c488192452
+  metadata.gz: b004c99544ed8e124ccdf1e699a421a0a70c1515ef2c095f26c2d50b0f76b97a
+  data.tar.gz: 40ff04003443747d336ff6cab8771849ceff5f97282160e4581674d75ea0baf6
 SHA512:
-  metadata.gz: daa02f43a1ad9615b1a1508c0b7fad026786131d2d4a6dd22b572dbea4b5e6ee1c8cce0ede8ea06a805a25d56c96e408c9d82d45d5e9be53bb4323e671274e37
-  data.tar.gz: 1cc10dee46a0c168e8a42923cc3f5322bc892ce62ac0f443b4231ce843a390f611f6ab2eda47d608db781f0d3222ba84ff4d1a6f69ad0c6458d5d1d1760bd2ce
+  metadata.gz: 5d8cda58c821abafe498dedb044e849c5cfb4e25a2e4d81e9113dee0c2bdb9927533421ac2046e32af84bc0f4092559d9b3996d6254f76f7afca78162fc71a9b
+  data.tar.gz: 42c3c4587b6aa2fba5848a0e67617000603f0729eaefd11826b45d138532f5bab604649518f0b078b9f80be8c5c206910353c790250f2ee7a6b49aafb3d854e0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steppy (1.0.1)
+    steppy (1.0.2)
 
 GEM
   remote: https://rubygems.org/

data/lib/steppy.rb

@@ -3,6 +3,8 @@
 require 'steppy/version'
 require 'steppy/cache'
 require 'steppy/error'
+require 'steppy/class_methods'
+require 'steppy/instance_methods'
 
 # The Steppy module you'll include in your classes to give them steps!
 module Steppy
@@ -26,267 +28,4 @@ module Steppy
 
     { 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 step_set(*sets)
-      steppy_cache[:sets] += sets
-    end
-
-    def step(method = nil, args = {}, &block)
-      steps.push(
-        Steppy.parse_step(method: method, args: args, block: block)
-      )
-      self
-    end
-
-    alias step_return step
-
-    def step_if(condition, &block)
-      steps.push(condition: condition, block: block)
-      self
-    end
-
-    def step_unless(condition, &block)
-      steps.push(condition: -> { !steppy_run_condition(condition) }, block: block)
-      self
-    end
-
-    def step_rescue(exceptions = nil, &block)
-      steppy_cache[:rescues].push(exceptions: exceptions, block: block)
-      self
-    end
-
-    def step_if_else(condition_block, step_steps, args = {})
-      if_step, else_step = step_steps
-
-      steps.push Steppy.parse_step(
-        method: if_step,
-        args: {
-          if: condition_block,
-        }.merge(args)
-      )
-
-      steps.push Steppy.parse_step(
-        method: else_step,
-        args: {
-          unless: condition_block,
-        }.merge(args)
-      )
-    end
-
-    def step_after(key = nil, &block)
-      step_add_callback(:after, block, key)
-    end
-
-    def step_before(key = nil, &block)
-      step_add_callback(:before, block, key)
-    end
-
-    def step_add_callback(type, block, key)
-      callback_key = key ? key.to_sym : :global
-      callbacks = step_callbacks[type][callback_key] ||= []
-      callbacks.push(block)
-    end
-
-    def steps
-      steppy_cache[:steps]
-    end
-
-    def step_callbacks
-      steppy_cache[:callbacks]
-    end
-
-    def steppy_cache
-      @steppy_cache ||= SteppyCache.new(
-        steps: [],
-        sets: [],
-        rescues: [],
-        callbacks: {
-          before: {
-            global: [],
-          },
-          after: {
-            global: [],
-          },
-        }
-      )
-    end
-  end
-
-  # Steppy instance methods that will be added.
-  module InstanceMethods
-    attr_reader :steppy_cache
-
-    def steppy(attributes = {}, cache = {})
-      steppy_initialize_cache({ attributes: attributes, prefix: :step }.merge(cache))
-
-      if steppy_cache.key?(:block)
-        instance_exec(&steppy_cache[:block])
-      else
-        steppy_run(steppy_cache)
-      end
-    rescue StandardError => exception
-      steppy_rescue exception, steppy_cache[:rescues]
-    end
-
-    def step_set(*sets)
-      steppy_sets(sets)
-    end
-
-    def step(method = nil, args = {}, &block)
-      steppy_run_step Steppy.parse_step(method: method, args: args, block: block)
-    end
-
-    alias step_return step
-
-    def step_if_else(condition_block, step_steps, args = {})
-      if_step, else_step = step_steps
-
-      steppy_run_step Steppy.parse_step(
-        method: if_step,
-        args: {
-          if: condition_block,
-        }.merge(args)
-      )
-
-      steppy_run_step Steppy.parse_step(
-        method: else_step,
-        args: {
-          unless: condition_block,
-        }.merge(args)
-      )
-    end
-
-    def step_if(condition, &block)
-      steppy_run_condition_block condition, block
-    end
-
-    def step_unless(condition, &block)
-      steppy_run_condition_block -> { !steppy_run_condition(condition) }, block
-    end
-
-    def step_rescue(*)
-      raise '#step_rescue can not be used in a block, please just add rescue to the #steppy block.'
-    end
-
-    protected
-
-    def steppy_run(steps:, sets:, **)
-      steppy_sets(sets)
-      steppy_steps(steps)
-    end
-
-    def steppy_sets(sets)
-      sets.each { |key, value| steppy_set(key, value || steppy_attributes[key]) }
-    end
-
-    def steppy_set(key, value)
-      key && instance_variable_set("@#{key}", value)
-    end
-
-    def steppy_steps(steps)
-      steps.each do |step|
-        condition = step[:condition]
-
-        steppy_cache[:result] = if condition
-          steppy_run_condition_block(condition, step[:block])
-        else
-          steppy_run_step(step)
-        end
-      end
-
-      steppy_result
-    end
-
-    def steppy_rescue(exception, rescues)
-      exception_class = exception.class
-      has_exception = exception_class == SteppyError || rescues.empty?
-
-      raise exception if has_exception
-
-      rescues.each do |exceptions:, block:|
-        if !exceptions || (exceptions && !exceptions.include?(exception_class))
-          steppy_cache[:result] = instance_exec(steppy_attributes, &block)
-        end
-      end
-
-      steppy_result
-    end
-
-    def steppy_run_condition_block(condition, block)
-      steppy_run(steppy_cache_from_block(block)) if steppy_run_condition(condition)
-    end
-
-    def steppy_run_condition(condition)
-      return true unless condition
-
-      if condition.arity > 0
-        instance_exec(steppy_attributes, &condition)
-      else
-        instance_exec(&condition)
-      end
-    end
-
-    def steppy_run_step(method:, args:, block:)
-      if !steppy_run_condition(args[:condition]) || (steppy_cache[:prefix] != args[:prefix])
-        return steppy_result
-      end
-
-      step_callbacks(:before, method, args, args)
-
-      result = if block
-        instance_exec(steppy_attributes, &block)
-      else
-        steppy_run_method(method, steppy_attributes)
-      end
-
-      step_callbacks(:after, method, result, args)
-
-      steppy_set(args[:set], result)
-
-      result
-    end
-
-    def step_callbacks(type, method, result, args)
-      callbacks = steppy_cache[:callbacks][type]
-      method_callbacks = (callbacks[method] || [])
-
-      callbacks[:global].concat(method_callbacks).each do |callback|
-        instance_exec(result, args, &callback)
-      end
-    end
-
-    def steppy_run_method(method_name, attributes)
-      method = "#{steppy_cache[:prefix]}_#{method_name}"
-
-      if method(method).arity > 0
-        public_send(method, attributes)
-      else
-        public_send(method)
-      end
-    end
-
-    def steppy_cache_from_block(block)
-      Class.new { include Steppy }.instance_exec(&block).steppy_cache
-    end
-
-    def steppy_initialize_cache(cache)
-      @steppy_cache = SteppyCache.new(
-        self.class.steppy_cache.to_h.merge(result: nil).merge(cache)
-      )
-    end
-
-    def steppy_attributes
-      steppy_cache[:attributes]
-    end
-
-    def steppy_result
-      steppy_cache[:result]
-    end
-  end
 end

data/lib/steppy/class_methods.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Steppy
+  # Steppy class methods that will be added to your included classes.
+  module ClassMethods
+    def steppy(&block)
+      steppy_cache[:block] = block
+    end
+
+    def step_set(*sets)
+      steppy_cache[:sets] += sets
+    end
+
+    def step(method = nil, args = {}, &block)
+      steps.push(
+        Steppy.parse_step(method: method, args: args, block: block)
+      )
+      self
+    end
+
+    alias step_return step
+
+    def step_if(condition, &block)
+      steps.push(condition: condition, block: block)
+      self
+    end
+
+    def step_unless(condition, &block)
+      steps.push(condition: -> { !steppy_run_condition(condition) }, block: block)
+      self
+    end
+
+    def step_rescue(exceptions = nil, &block)
+      steppy_cache[:rescues].push(exceptions: exceptions, block: block)
+      self
+    end
+
+    def step_if_else(condition_block, step_steps, args = {})
+      if_step, else_step = step_steps
+
+      steps.push Steppy.parse_step(
+        method: if_step,
+        args: {
+          if: condition_block,
+        }.merge(args)
+      )
+
+      steps.push Steppy.parse_step(
+        method: else_step,
+        args: {
+          unless: condition_block,
+        }.merge(args)
+      )
+    end
+
+    def step_after(key = nil, &block)
+      step_add_callback(:after, block, key)
+    end
+
+    def step_before(key = nil, &block)
+      step_add_callback(:before, block, key)
+    end
+
+    def step_add_callback(type, block, key)
+      callback_key = key ? key.to_sym : :global
+      callbacks = step_callbacks[type][callback_key] ||= []
+      callbacks.push(block)
+    end
+
+    def steps
+      steppy_cache[:steps]
+    end
+
+    def step_callbacks
+      steppy_cache[:callbacks]
+    end
+
+    def steppy_cache
+      @steppy_cache ||= SteppyCache.new(
+        steps: [],
+        sets: [],
+        rescues: [],
+        callbacks: {
+          before: {
+            global: [],
+          },
+          after: {
+            global: [],
+          },
+        }
+      )
+    end
+  end
+end

data/lib/steppy/instance_methods.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Steppy
+  # Steppy instance methods that will be added.
+  module InstanceMethods
+    attr_reader :steppy_cache
+
+    def steppy(attributes = {}, cache = {})
+      steppy_initialize_cache({ attributes: attributes, prefix: :step }.merge(cache))
+
+      if steppy_cache.key?(:block)
+        instance_exec(&steppy_cache[:block])
+      else
+        steppy_run(steppy_cache)
+      end
+    rescue StandardError => exception
+      steppy_rescue exception, steppy_cache[:rescues]
+    end
+
+    def step_set(*sets)
+      steppy_sets(sets)
+    end
+
+    def step(method = nil, args = {}, &block)
+      steppy_run_step Steppy.parse_step(method: method, args: args, block: block)
+    end
+
+    alias step_return step
+
+    def step_if_else(condition_block, step_steps, args = {})
+      if_step, else_step = step_steps
+
+      steppy_run_step Steppy.parse_step(
+        method: if_step,
+        args: {
+          if: condition_block,
+        }.merge(args)
+      )
+
+      steppy_run_step Steppy.parse_step(
+        method: else_step,
+        args: {
+          unless: condition_block,
+        }.merge(args)
+      )
+    end
+
+    def step_if(condition, &block)
+      steppy_run_condition_block condition, block
+    end
+
+    def step_unless(condition, &block)
+      steppy_run_condition_block -> { !steppy_run_condition(condition) }, block
+    end
+
+    def step_rescue(*)
+      raise '#step_rescue can not be used in a block, please just add rescue to the #steppy block.'
+    end
+
+    protected
+
+    def steppy_run(steps:, sets:, **)
+      steppy_sets(sets)
+      steppy_steps(steps)
+    end
+
+    def steppy_sets(sets)
+      sets.each { |key, value| steppy_set(key, value || steppy_attributes[key]) }
+    end
+
+    def steppy_set(key, value)
+      key && instance_variable_set("@#{key}", value)
+    end
+
+    def steppy_steps(steps)
+      steps.each do |step|
+        condition = step[:condition]
+
+        steppy_cache[:result] = if condition
+          steppy_run_condition_block(condition, step[:block])
+        else
+          steppy_run_step(step)
+        end
+      end
+
+      steppy_result
+    end
+
+    def steppy_rescue(exception, rescues)
+      exception_class = exception.class
+      has_exception = exception_class == SteppyError || rescues.empty?
+
+      raise exception if has_exception
+
+      rescues.each do |exceptions:, block:|
+        if !exceptions || (exceptions && !exceptions.include?(exception_class))
+          steppy_cache[:result] = instance_exec(steppy_attributes, &block)
+        end
+      end
+
+      steppy_result
+    end
+
+    def steppy_run_condition_block(condition, block)
+      steppy_run(steppy_cache_from_block(block)) if steppy_run_condition(condition)
+    end
+
+    def steppy_run_condition(condition)
+      return true unless condition
+
+      if condition.arity > 0
+        instance_exec(steppy_attributes, &condition)
+      else
+        instance_exec(&condition)
+      end
+    end
+
+    def steppy_run_step(method:, args:, block:)
+      if !steppy_run_condition(args[:condition]) || (steppy_cache[:prefix] != args[:prefix])
+        return steppy_result
+      end
+
+      step_run_callbacks(:before, method, args, args)
+
+      result = if block
+        instance_exec(steppy_attributes, &block)
+      else
+        steppy_run_method(method, steppy_attributes)
+      end
+
+      step_run_callbacks(:after, method, result, args)
+
+      steppy_set(args[:set], result)
+
+      result
+    end
+
+    def step_run_callbacks(type, method, result, args)
+      callbacks = step_callbacks[type]
+      method_callbacks = callbacks[method] || []
+
+      callbacks[:global].each do |callback|
+        instance_exec(result, args, &callback)
+      end
+
+      method_callbacks.each do |callback|
+        instance_exec(result, args, &callback)
+      end
+    end
+
+    def steppy_run_method(method_name, attributes)
+      method = "#{steppy_cache[:prefix]}_#{method_name}"
+
+      if method(method).arity > 0
+        public_send(method, attributes)
+      else
+        public_send(method)
+      end
+    end
+
+    def step_callbacks
+      steppy_cache[:callbacks]
+    end
+
+    def steppy_cache_from_block(block)
+      Class.new { include Steppy }.instance_exec(&block).steppy_cache
+    end
+
+    def steppy_initialize_cache(cache)
+      @steppy_cache = SteppyCache.new(
+        self.class.steppy_cache.to_h.merge(result: nil).merge(cache)
+      )
+    end
+
+    def steppy_attributes
+      steppy_cache[:attributes]
+    end
+
+    def steppy_result
+      steppy_cache[:result]
+    end
+  end
+end

data/lib/steppy/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: steppy
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - cj
@@ -158,7 +158,9 @@ files:
 - hooks/pre-commit
 - lib/steppy.rb
 - lib/steppy/cache.rb
+- lib/steppy/class_methods.rb
 - lib/steppy/error.rb
+- lib/steppy/instance_methods.rb
 - lib/steppy/version.rb
 - steppy.gemspec
 homepage: https://github.com/cj/steppy