arq 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83941043c326bd9f80903aa4755c49ae3affe39584f12d3757ab8a05e0878987
-  data.tar.gz: d94724fe95ba5dfe444c3d2587357ec60c825a61c5a0a5743a55b8c44c2b3b05
+  metadata.gz: bf6593b58efb70d3d2ac268f33cb8eae378fe821d13e69975c13216cdfe1ff2f
+  data.tar.gz: fa4401c24cd50c2d8a5b6f7adb69e3224e126d75c166fca994f816ceb27e4523
 SHA512:
-  metadata.gz: 418c2ba2e7f9373056b1eb52503c9af47749921c8c696bdf4dce98bcf0649684eab3f2a48742f3943aed00839c1e776178e0fc4b0932409203d7c04891fa52bf
-  data.tar.gz: 543ada56b97ebef9d58fd01e614583aca4a123707917bd3d11607e2645c6ae4688db1b942be279fd0fac86c0986d6d5f7d9c9c198d8ee5742efaffbcced27f88
+  metadata.gz: a9feae6ec6e4ff17c37a2af7d99b7df6ec22e1d1fce6af04e42444bdff3e250b44e2c8036d64b333620929cd0d75bd5e0f69058e09d190dc49438ca2e2d456d9
+  data.tar.gz: 297f51c062e329349999b9b370c1f1fc91ba17f90e2b57baf141fc44df6aae3ae97086eef293108204417b94143814ba1e8f512deb9f89d31022c7eb37e5287d

data/lib/arq/action.rb

@@ -1,55 +1,173 @@
 # 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 modules and dot accessors.
+      # IE `Foo::Bar::Action` can be called via `foo.bar.action`
+      def method_missing(method, *args, &block)
+        obj = Object.const_get(method.to_s.camelize)
+        case obj
+        when Arq::Action
+          call_other(obj)
+        when Module
+          Arq::ModuleHash.new(obj, self)
+        end
+      rescue NameError => _e
+        super
+      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/module_hash.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Arq
+  # Allows for dot-accessing of modules.
+  # Child modules are automatically wrapped and actions are called.
+  class ModuleHash < Hash
+    def initialize(mod, action_inst)
+      super()
+
+      @module = mod
+      @action_inst = action_inst
+    end
+
+    def method_missing(method, *args, &block)
+      wrap(@module.const_get(method.to_s.camelize))
+    rescue NameError => _e
+      super
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @module.const_defined?(method.to_s.camelize.to_sym) || super
+    end
+
+    private
+
+    # If the value is a Module, it's returned as a ModuleHash.
+    def wrap(value)
+      case value
+      when Arq::Action
+        @action_inst.call_other(value)
+      when Module
+        self.class.new(value, @action_inst)
+      else
+        value
+      end
+    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.0"
 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/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.0
 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.
@@ -22,7 +22,7 @@ files:
 - lib/arq/action.rb
 - lib/arq/context.rb
 - lib/arq/errors.rb
-- lib/arq/runnable.rb
+- lib/arq/module_hash.rb
 - lib/arq/version.rb
 homepage: https://github.com/kphan32/arq
 licenses:

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