arq 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83941043c326bd9f80903aa4755c49ae3affe39584f12d3757ab8a05e0878987
-  data.tar.gz: d94724fe95ba5dfe444c3d2587357ec60c825a61c5a0a5743a55b8c44c2b3b05
+  metadata.gz: a0ee16565eecb2e2866939a75dae3fde195f0c941bddb66f43f98ccc92c0e642
+  data.tar.gz: 2e4ca8c155a462706ca2668b18bac36c38fac84b025f00f4b59f54d0d478a382
 SHA512:
-  metadata.gz: 418c2ba2e7f9373056b1eb52503c9af47749921c8c696bdf4dce98bcf0649684eab3f2a48742f3943aed00839c1e776178e0fc4b0932409203d7c04891fa52bf
-  data.tar.gz: 543ada56b97ebef9d58fd01e614583aca4a123707917bd3d11607e2645c6ae4688db1b942be279fd0fac86c0986d6d5f7d9c9c198d8ee5742efaffbcced27f88
+  metadata.gz: 047d23d860d49a35f90564695578e776b35e3628d9f53681de8db4d2c4eaee407a8bae985983015c2e843e67bc70857e1ad173dfbb93d081cfeb9fdd7cf87dd8
+  data.tar.gz: 34f0ca90c2783f25623c1dfd464e7e4b7dce0677e187647678876aad0a5927b856bc77ed6e3d75bfd460a76f2488f0a5e9f084e6a80f3f76b23bb8ab5b5e7238

data/lib/arq/action.rb

@@ -1,55 +1,176 @@
 # frozen_string_literal: true
 
 module Arq
-  # Module to extend to create an action. Exposes confing functions #call, #params, and #returns.
+  # Module to extend to create an action.
+  # Class methods are used to configure the action itself.
+  # Instance methods are exposed to the block passed into `run`.
   module Action
-    def call(ctx = Arq::Context.new)
-      ctx = transform_input_context(ctx)
-
-      generate_runnable(ctx).call
-
-      ctx
+    def self.extended(base)
+      base.extend(ClassMethods)
+      base.include(InstanceMethods)
     end
 
-    def params(*keys)
-      params_list.concat(keys).compact
+    def self.included(_base)
+      raise "`Arq::Action` should be `extended`"
     end
 
-    def returns(*keys)
-      returns_list.concat(keys).compact
-    end
+    # Methods and fields exposed to configure the action.
+    module ClassMethods
+      # Runs the stored block with variables from the provided context.
+      def call(ctx = Arq::Context.new)
+        ctx = transform_input_context(ctx)
 
-    def run(&block)
-      @run_block = block
-    end
+        inst = new(ctx)
+        inst.run
 
-    private
-
-    def transform_input_context(ctx)
-      case ctx
-      when Arq::Context
         ctx
-      when Hash
-        Arq::Context.new(ctx)
-      else
-        raise Arq::InvalidContextParameterError
       end
-    end
 
-    def generate_runnable(ctx)
-      Arq::Runnable.new(ctx, params_list, returns_list, &run_block)
-    end
+      def params_list
+        @params_list ||= []
+      end
 
-    def params_list
-      @params_list ||= []
-    end
+      def returns_list
+        @returns_list ||= []
+      end
+
+      def run_block
+        @run_block ||= nil
+      end
+
+      private
 
-    def returns_list
-      @returns_list ||= []
+      # Ensures that a valid context is passed and returned.
+      # Acceptable values are Context or Hash objects.
+      def transform_input_context(ctx)
+        case ctx
+        when Arq::Context
+          ctx
+        when Hash
+          Arq::Context.new(ctx)
+        else
+          raise Arq::InvalidContextParameterError
+        end
+      end
+
+      def params(*keys)
+        params_list.concat(keys).compact
+      end
+
+      def returns(*keys)
+        returns_list.concat(keys).compact
+      end
+
+      def run(&block)
+        return "Block required" unless block_given?
+
+        @run_block = block
+      end
     end
 
-    def run_block
-      @run_block ||= nil
+    # Methods and fields exposed to the run block.
+    module InstanceMethods
+      def initialize(ctx)
+        @_ctx = ctx
+      end
+
+      # This is the entry-point for the action's execution.
+      # rubocop:disable Metrics/MethodLength
+      def run
+        return if @_ctx.failure?
+
+        _validate_required_params
+        _import_context
+
+        # Suppress `FailureError`s since they're used to just exit the action.
+        begin
+          # Instance eval to expose instance variables.
+          instance_eval(&self.class.run_block)
+        rescue Arq::FailureError
+          nil
+        end
+
+        _export_variables
+
+        # Only validate returns if context is successful
+        _validate_required_returns if @_ctx.success?
+
+        nil
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # Used to call another action using the current action's context.
+      # Because of this, the context is exported and then imported again.
+      def call_other(action)
+        _export_variables
+        action.call(@_ctx)
+        _import_context
+      end
+
+      # Fails the context without exiting the current action.
+      def fail!(message = nil)
+        @_ctx.fail!(message)
+      end
+
+      # Fails the context and exits the current action.
+      def fail_now!(message = nil)
+        @_ctx.fail_now!(message)
+      end
+
+      # Used to easily call other actions via snake-cased paths with dot accessors.
+      # IE `Foo::Bar::Action` can be called via `foo.bar.action`
+      def method_missing(method, *args, &block)
+        # Format method as module path.
+        formatted = method.to_s.camelize
+
+        # Attempt to find object.
+        obj = if Object.const_defined?(formatted)
+                Object.const_get(formatted)
+              else
+                return super
+              end
+
+        # Defer handling to ActionModuleHash
+        Arq::ActionModuleHash.from(obj, self)
+      end
+
+      def respond_to_missing?(method, include_private: false)
+        Object.const_defined?(method.to_s.camelize) || super
+      end
+
+      private
+
+      # Load parameters of context as instance variables
+      def _import_context
+        @_ctx.each do |key, val|
+          instance_variable_set(:"@#{key}", val)
+        end
+      end
+
+      # Exports instance variables (excluding those prefixed with _) to the context
+      def _export_variables
+        # Filter out vars starting with _
+        vars = instance_variables.filter do |key|
+          !key.start_with?("@_")
+        end
+
+        vars.each do |var|
+          # Strip @ prefix
+          key = var[1..].to_sym
+
+          @_ctx[key] = instance_variable_get(var)
+        end
+      end
+
+      def _validate_required_params
+        missing_params = (self.class.params_list - @_ctx.keys)
+        raise Arq::ParametersNotInContextError, missing_params unless missing_params.empty?
+      end
+
+      def _validate_required_returns
+        missing_returns = (self.class.returns_list - @_ctx.keys)
+        raise Arq::ReturnValuesNotInContextError, missing_returns unless missing_returns.empty?
+      end
     end
   end
 end

data/lib/arq/action_module_hash.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Arq
+  # Allows for dot-accessing of modules and running of actions.
+  # Child modules are automatically wrapped and actions are called.
+  class ActionModuleHash < Hash
+    # Calls action or wraps in hash class if module.
+    def self.from(obj, action_inst)
+      case obj
+      when Arq::Action
+        action_inst.call_other(obj)
+      when Module
+        new(obj, action_inst)
+      else
+        raise "Object must be an Action or Module"
+      end
+    end
+
+    def initialize(mod, action_inst)
+      super()
+
+      @module = mod
+      @action_inst = action_inst
+    end
+
+    def method_missing(method, *args, &block)
+      # Format method as module path.
+      formatted = method.to_s.camelize
+
+      # Attempt to find object.
+      obj = if Object.const_defined?(formatted)
+              Object.const_get(formatted)
+            else
+              return super
+            end
+
+      self.class.from(obj)
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @module.const_defined?(method.to_s.camelize.to_sym) || super
+    end
+  end
+end

data/lib/arq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Arq
-  VERSION = "0.2.1"
+  VERSION = "0.3.1"
 end

data/lib/arq.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/string"
+
 require_relative "arq/version"
 require_relative "arq/errors"
 require_relative "arq/context"
-require_relative "arq/runnable"
+require_relative "arq/action_module_hash"
 require_relative "arq/action"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arq
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Kavin Phan
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-09 00:00:00.000000000 Z
+date: 2022-09-29 00:00:00.000000000 Z
 dependencies: []
 description: A service skeleton framework heavily inspired by LightService with the
   primary goal of being less verbose.
@@ -20,9 +20,9 @@ extra_rdoc_files: []
 files:
 - lib/arq.rb
 - lib/arq/action.rb
+- lib/arq/action_module_hash.rb
 - lib/arq/context.rb
 - lib/arq/errors.rb
-- lib/arq/runnable.rb
 - lib/arq/version.rb
 homepage: https://github.com/kphan32/arq
 licenses:
@@ -48,7 +48,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A simple service skeleton framework

data/lib/arq/runnable.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-module Arq
-  # Represents a process to run with a given context, parameters, and returns.
-  # A Runnable is generated from an Action.
-  class Runnable
-    def initialize(ctx, params = [], returns = [], &block)
-      @ctx     = ctx
-      @params  = params
-      @returns = returns
-      @block   = block
-    end
-
-    def call
-      return if @ctx.failure?
-
-      validate_required_params
-
-      val = run_block
-
-      # If the block returned an array, attempt to run
-      run_sequence(val) if val.is_a?(Array)
-
-      # Only validate returns if context is successful
-      validate_required_returns if @ctx.success?
-
-      val
-    end
-
-    def run(&block)
-      Arq::Runnable.new(@ctx, [], [], &block)
-    end
-
-    def fail!(message = nil)
-      @ctx.fail!(message)
-    end
-
-    def fail_now!(message = nil)
-      @ctx.fail_now!(message)
-    end
-
-    private
-
-    def run_block
-      with_context do
-        instance_eval(&@block)
-      rescue Arq::FailureError
-        nil
-      end
-    end
-
-    def run_sequence(sequence)
-      sequence.each do |e|
-        case e
-        when Arq::Action
-          e.call(@ctx)
-        when Arq::Runnable
-          e.call
-        end
-      end
-    end
-
-    # Runs the block with context parameters set as instance variables, then
-    # imports all context parameters and any new instance vars into the context.
-    # Returns the return value of the block.
-    def with_context
-      # Grab all current variables to know what is being returned
-      before_vars = instance_variables
-
-      # Load all context parameters into runnable instance
-      import_context_to_vars
-
-      # Run block
-      val = yield
-
-      # Grab all ctx + new vars
-      ctx_vars = instance_variables - before_vars
-
-      # Import instance vars into ctx
-      import_vars_to_context(ctx_vars)
-
-      # Return block value
-      val
-    end
-
-    def import_context_to_vars
-      @ctx.each do |key, val|
-        instance_variable_set(:"@#{key}", val)
-      end
-    end
-
-    def import_vars_to_context(vars)
-      vars.each do |var|
-        key = var[1..].to_sym
-        @ctx[key] = instance_variable_get(var)
-      end
-    end
-
-    def validate_required_params
-      missing_params = (@params - @ctx.keys)
-      raise Arq::ParametersNotInContextError, missing_params unless missing_params.empty?
-    end
-
-    def validate_required_returns
-      missing_returns = (@returns - @ctx.keys)
-      raise Arq::ReturnValuesNotInContextError, missing_returns unless missing_returns.empty?
-    end
-  end
-end