simple-service 0.1.3 → 0.2.0

data/lib/simple/workflow.rb

@@ -0,0 +1,96 @@
+require "simple/service"
+
+require_relative "workflow/context"
+require_relative "workflow/current_context"
+require_relative "workflow/reloader"
+
+if defined?(RSpec)
+  require_relative "workflow/rspec_helper"
+end
+
+module Simple::Workflow
+  class ContextMissingError < ::StandardError
+    def to_s
+      "Simple::Workflow.current_context not initialized; remember to call Simple::Workflow.with_context/1"
+    end
+  end
+
+  module HelperMethods
+    def invoke(*args, **kwargs)
+      Simple::Workflow.invoke(self, *args, **kwargs)
+    end
+  end
+
+  module InstanceHelperMethods
+    private
+
+    def current_context
+      Simple::Workflow.current_context
+    end
+  end
+
+  module ModuleMethods
+    def register_workflow(mod)
+      expect! mod => Module
+
+      mod.extend ::Simple::Workflow::HelperMethods
+      mod.include ::Simple::Workflow::InstanceHelperMethods
+      mod.extend mod
+      mod.include Simple::Service
+    end
+
+    def reload_on_invocation?
+      !!@reload_on_invocation
+    end
+
+    def reload_on_invocation!
+      @reload_on_invocation = true
+    end
+
+    def invoke(workflow, *args, **kwargs)
+      # This call to Simple::Workflow.current_context raises a ContextMissingError
+      # if the context is not set.
+      _ = ::Simple::Workflow.current_context
+
+      expect! workflow => [Module, String]
+
+      workflow_module = lookup_workflow!(workflow)
+
+      # We will reload workflow modules only once per invocation.
+      if Simple::Workflow.reload_on_invocation?
+        Simple::Workflow.current_context.reload!(workflow_module)
+      end
+
+      Simple::Service.invoke(workflow_module, :call, args: args, flags: kwargs.transform_keys(&:to_s))
+    end
+
+    private
+
+    def lookup_workflow!(workflow)
+      workflow_module = lookup_workflow(workflow)
+
+      verify_workflow! workflow_module
+
+      workflow_module
+    end
+
+    def lookup_workflow(workflow)
+      case workflow
+      when Module
+        workflow
+      when String
+        Object.const_get workflow
+      else
+        expect! workflow => [Module, String]
+      end
+    end
+
+    def verify_workflow!(workflow_module)
+      return if Simple::Service.actions(workflow_module).key?(:call)
+
+      raise ArgumentError, "#{workflow_module.name} is not a Simple::Workflow"
+    end
+  end
+
+  extend ModuleMethods
+end

data/lib/simple-workflow.rb

@@ -0,0 +1,3 @@
+# rubocop:disable Naming/FileName
+
+require "simple/workflow"

data/scripts/test

@@ -0,0 +1,2 @@
+#!/bin/bash
+rspec "$@"

data/simple-service.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version = '~> 2.5'
 
   gem.add_dependency "expectation", "~> 1"
+  gem.add_dependency "simple-immutable", "~> 1", ">= 1.1"
 end

data/spec/simple/service/action_invoke3_spec.rb

@@ -0,0 +1,258 @@
+# rubocop:disable Style/WordArray
+
+require "spec_helper"
+
+describe "Simple::Service.invoke3" do
+  let(:service) { InvokeTestService }
+  let(:action)  { nil }
+
+  # a shortcut
+  def invoke3!(*args, **keywords)
+    @actual = ::Simple::Service.invoke3(service, action, *args, **keywords)
+    # rescue ::StandardError => e
+  rescue ::Simple::Service::ArgumentError => e
+    @actual = e
+  end
+
+  attr_reader :actual
+
+  # when calling #invoke3 using positional arguments they will be matched against
+  # positional arguments of the invoke3d method - but they will not be matched
+  # against named arguments.
+  #
+  # When there are not enough positional arguments to match the number of required
+  # positional arguments of the method we raise an ArgumentError.
+  #
+  # When there are more positional arguments provided than the number accepted
+  # by the method we raise an ArgumentError.
+
+  context "calling an action w/o parameters" do
+    # reminder: this is the definition of no_params
+    #
+    # def no_params
+    #   "service2 return"
+    # end
+
+    let(:action) { :no_params }
+
+    context "calling without args" do
+      it "runs the action" do
+        invoke3!
+        expect(actual).to eq("service2 return")
+      end
+    end
+
+    context "calling with extra positional args" do
+      it "raises ExtraArguments" do
+        invoke3!("foo", "bar")
+        expect(actual).to be_a(::Simple::Service::ExtraArguments)
+        expect(actual.to_s).to match(/"foo", "bar"/)
+      end
+    end
+
+    context "calling with extra named args" do
+      it "ignores extra args" do
+        invoke3!(foo: "foo", bar: "bar")
+        expect(actual).to eq("service2 return")
+      end
+    end
+
+    context "calling with an additional hash arg" do
+      xit "ignores extra args" do
+        args = []
+        args.push foo: "foo", bar: "bar"
+        invoke3!(*args)
+
+        expect(actual).to be_a(::Simple::Service::ExtraArguments)
+      end
+    end
+  end
+
+  context "calling an action w/positional parameters" do
+    # reminder: this is the definition of positional_params
+    #
+    # def positional_params(a, b, c = "speed-of-light", e = 2.781)
+    #   [a, b, c, e]
+    # end
+
+    let(:action) { :positional_params }
+
+    context "without args" do
+      it "raises MissingArguments" do
+        invoke3!
+        expect(actual).to be_a(::Simple::Service::MissingArguments)
+      end
+    end
+
+    context "with the required number of args" do
+      it "runs" do
+        invoke3!("foo", "bar")
+        expect(actual).to eq(["foo", "bar", "speed-of-light", 2.781])
+      end
+    end
+
+    context "with the allowed number of args" do
+      it "runs" do
+        invoke3!("foo", "bar", "baz", "number4")
+        expect(actual).to eq(%w[foo bar baz number4])
+      end
+    end
+
+    context "with more than the allowed number of args" do
+      it "raises ExtraArguments" do
+        invoke3!("foo", "bar", "baz", "number4", "extra")
+        expect(actual).to be_a(::Simple::Service::ExtraArguments)
+      end
+    end
+
+    context "calling with extra named args" do
+      it "ignores extra args" do
+        invoke3!("foo", "bar", "baz", extra3: 3)
+        expect(actual).to eq(["foo", "bar", "baz", 2.781])
+      end
+    end
+
+    context "calling with an additional hash arg" do
+      xit "raises ExtraArguments" do
+        args = ["foo", "bar", "baz", extra3: 3]
+        invoke3!(*args)
+        expect(actual).to be_a(::Simple::Service::ExtraArguments)
+      end
+    end
+  end
+
+  context "calling an action w/named parameters" do
+    # reminder: this is the definition of named_params
+    #
+    # def named_params(a:, b:, c: "speed-of-light", e: 2.781)
+    #   [a, b, c, e]
+    # end
+
+    let(:action) { :named_params }
+
+    context "without args" do
+      it "raises MissingArguments" do
+        invoke3!
+        expect(actual).to be_a(::Simple::Service::MissingArguments)
+      end
+    end
+
+    context "with the required number of args" do
+      it "runs" do
+        invoke3!(a: "foo", b: "bar")
+        expect(actual).to eq(["foo", "bar", "speed-of-light", 2.781])
+      end
+    end
+
+    context "with the allowed number of args" do
+      it "runs" do
+        invoke3!(a: "foo", b: "bar", c: "baz", e: "number4")
+        expect(actual).to eq(%w[foo bar baz number4])
+      end
+    end
+
+    context "with more than the allowed number of args" do
+      it "runs" do
+        invoke3!("foo", "bar", "baz", "number4", "extra")
+        expect(actual).to be_a(::Simple::Service::ExtraArguments)
+      end
+    end
+
+    context "with extra named args" do
+      it "ignores extra args" do
+        invoke3!(a: "foo", b: "bar", c: "baz", extra3: 3)
+        expect(actual).to eq(["foo", "bar", "baz", 2.781])
+      end
+    end
+  end
+
+  context "calling an action w/mixed and optional parameters" do
+    # reminder: this is the definition of named_params
+    #
+    # def mixed_optional_params(a, b = "default-b", c = "speed-of-light", e: 2.781)
+    #   [a, b, c, e]
+    # end
+
+    let(:action) { :mixed_optional_params }
+
+    context "without args" do
+      it "raises MissingArguments" do
+        invoke3!
+        expect(actual).to be_a(::Simple::Service::MissingArguments)
+      end
+    end
+
+    context "with the required number of args" do
+      it "runs" do
+        invoke3!("foo")
+        expect(actual).to eq(["foo", "default-b", "speed-of-light", 2.781])
+      end
+    end
+
+    context "with the allowed number of args" do
+      it "runs" do
+        invoke3!("foo", "bar", "baz", e: "number4")
+        expect(actual).to eq(%w[foo bar baz number4])
+      end
+    end
+
+    context "with more than the allowed number of args" do
+      it "runs" do
+        invoke3!("foo", "bar", "baz", "extra", e: "number4")
+        expect(actual).to be_a(::Simple::Service::ExtraArguments)
+      end
+    end
+
+    context "with extra named args" do
+      it "ignores extra args" do
+        invoke3!("foo", "bar", "baz", e: "number4", extra3: 3)
+        expect(actual).to eq(["foo", "bar", "baz", "number4"])
+      end
+    end
+  end
+
+  context "calling an action w/mixed and variadic parameters" do
+    # reminder: this is the definition of variadic_params
+    #
+    # def variadic_params(a, b = "queen bee", *args, e: 2.781)
+    #   [a, b, args, e]
+    # end
+
+    let(:action) { :variadic_params }
+
+    context "without args" do
+      it "raises MissingArguments" do
+        invoke3!
+        expect(actual).to be_a(::Simple::Service::MissingArguments)
+      end
+    end
+
+    context "with the required number of args" do
+      it "runs" do
+        invoke3!("foo")
+        expect(actual).to eq(["foo", "queen bee", [], 2.781])
+      end
+    end
+
+    context "with the allowed number of args" do
+      it "runs" do
+        invoke3!("foo", "bar", "baz", e: "number4")
+        expect(actual).to eq(["foo", "bar", ["baz"], "number4"])
+      end
+    end
+
+    context "with more than the allowed number of args" do
+      it "runs" do
+        invoke3!("foo", "bar", "baz", "extra", e: "number4")
+        expect(actual).to eq(["foo", "bar", ["baz", "extra"], "number4"])
+      end
+    end
+
+    context "with extra named args" do
+      it "ignores extra args" do
+        invoke3!("foo", "bar", "baz", e: "number4", extra3: 3)
+        expect(actual).to eq(["foo", "bar", ["baz"], "number4"])
+      end
+    end
+  end
+end

data/spec/simple/service/action_invoke_spec.rb

@@ -1,22 +1,13 @@
 # rubocop:disable Style/WordArray
-
 require "spec_helper"
 
 describe "Simple::Service.invoke" do
-  # the context to use in the around hook below. By default this is nil -
-  # which gives us an empty context.
-  let(:context) { nil }
-
-  around do |example|
-    ::Simple::Service.with_context(context) { example.run }
-  end
-
   let(:service) { InvokeTestService }
   let(:action)  { nil }
 
   # a shortcut
-  def invoke!(*args, **keywords)
-    @actual = ::Simple::Service.invoke(service, action, *args, **keywords)
+  def invoke!(args: {}, flags: {})
+    @actual = ::Simple::Service.invoke(service, action, args: args, flags: flags)
     # rescue ::StandardError => e
   rescue ::Simple::Service::ArgumentError => e
     @actual = e
@@ -24,16 +15,6 @@ describe "Simple::Service.invoke" do
 
   attr_reader :actual
 
-  # when calling #invoke using positional arguments they will be matched against
-  # positional arguments of the invoked method - but they will not be matched
-  # against named arguments.
-  #
-  # When there are not enough positional arguments to match the number of required
-  # positional arguments of the method we raise an ArgumentError.
-  #
-  # When there are more positional arguments provided than the number accepted
-  # by the method we raise an ArgumentError.
-
   context "calling an action w/o parameters" do
     # reminder: this is the definition of no_params
     #
@@ -50,28 +31,17 @@ describe "Simple::Service.invoke" do
       end
     end
 
-    context "calling with extra positional args" do
-      it "raises ExtraArguments" do
-        invoke!("foo", "bar")
-        expect(actual).to be_a(::Simple::Service::ExtraArguments)
-        expect(actual.to_s).to match(/"foo", "bar"/)
-      end
-    end
-
     context "calling with extra named args" do
       it "ignores extra args" do
-        invoke!(foo: "foo", bar: "bar")
+        invoke!(args: { "foo" => "foo", "bar" => "bar" })
         expect(actual).to eq("service2 return")
       end
     end
 
-    context "calling with an additional hash arg" do
-      xit "ignores extra args" do
-        args = []
-        args.push foo: "foo", bar: "bar"
-        invoke!(*args)
-
-        expect(actual).to be_a(::Simple::Service::ExtraArguments)
+    context "calling with extra flags" do
+      it "ignores extra args" do
+        invoke!(flags: { "foo" => "foo", "bar" => "bar" })
+        expect(actual).to eq("service2 return")
       end
     end
   end
@@ -89,42 +59,35 @@ describe "Simple::Service.invoke" do
       it "raises MissingArguments" do
         invoke!
         expect(actual).to be_a(::Simple::Service::MissingArguments)
+        expect(actual.to_s).to match(/\ba, b\b/)
       end
     end
 
     context "with the required number of args" do
       it "runs" do
-        invoke!("foo", "bar")
+        invoke!(args: { "a" => "foo", "b" => "bar" })
         expect(actual).to eq(["foo", "bar", "speed-of-light", 2.781])
       end
     end
 
-    context "with the allowed number of args" do
-      it "runs" do
-        invoke!("foo", "bar", "baz", "number4")
-        expect(actual).to eq(%w[foo bar baz number4])
+    context "with the required number of args and flags" do
+      it "merges flags and args to provide arguments" do
+        invoke!(args: { "a" => "foo" }, flags: { "b" => "bar" })
+        expect(actual).to eq(["foo", "bar", "speed-of-light", 2.781])
       end
     end
 
-    context "with more than the allowed number of args" do
-      it "raises ExtraArguments" do
-        invoke!("foo", "bar", "baz", "number4", "extra")
-        expect(actual).to be_a(::Simple::Service::ExtraArguments)
+    context "with the allowed number of args" do
+      it "runs" do
+        invoke!(args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4" })
+        expect(actual).to eq(%w[foo bar baz number4])
       end
     end
 
     context "calling with extra named args" do
       it "ignores extra args" do
-        invoke!("foo", "bar", "baz", extra3: 3)
-        expect(actual).to eq(["foo", "bar", "baz", 2.781])
-      end
-    end
-
-    context "calling with an additional hash arg" do
-      xit "raises ExtraArguments" do
-        args = ["foo", "bar", "baz", extra3: 3]
-        invoke!(*args)
-        expect(actual).to be_a(::Simple::Service::ExtraArguments)
+        invoke!(args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4", "extra3" => 3 })
+        expect(actual).to eq(%w[foo bar baz number4])
       end
     end
   end
@@ -132,7 +95,7 @@ describe "Simple::Service.invoke" do
   context "calling an action w/named parameters" do
     # reminder: this is the definition of named_params
     #
-    # def named_params(a:, b:, c: "speed-of-light", e: 2.781)
+    # def named_params(a:, b:, "c" => "speed-of-light", e: 2.781)
     #   [a, b, c, e]
     # end
 
@@ -142,33 +105,27 @@ describe "Simple::Service.invoke" do
       it "raises MissingArguments" do
         invoke!
         expect(actual).to be_a(::Simple::Service::MissingArguments)
+        expect(actual.to_s).to match(/\ba, b\b/)
       end
     end
 
     context "with the required number of args" do
       it "runs" do
-        invoke!(a: "foo", b: "bar")
+        invoke!(args: { "a" => "foo", "b" => "bar" })
         expect(actual).to eq(["foo", "bar", "speed-of-light", 2.781])
       end
     end
 
     context "with the allowed number of args" do
       it "runs" do
-        invoke!(a: "foo", b: "bar", c: "baz", e: "number4")
+        invoke!(args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4" })
         expect(actual).to eq(%w[foo bar baz number4])
       end
     end
 
-    context "with more than the allowed number of args" do
-      it "runs" do
-        invoke!("foo", "bar", "baz", "number4", "extra")
-        expect(actual).to be_a(::Simple::Service::ExtraArguments)
-      end
-    end
-
     context "with extra named args" do
       it "ignores extra args" do
-        invoke!(a: "foo", b: "bar", c: "baz", extra3: 3)
+        invoke!(args: { "a" => "foo", "b" => "bar", "c" => "baz", "extra3" => 3 })
         expect(actual).to eq(["foo", "bar", "baz", 2.781])
       end
     end
@@ -192,28 +149,21 @@ describe "Simple::Service.invoke" do
 
     context "with the required number of args" do
       it "runs" do
-        invoke!("foo")
+        invoke!(args: { "a" => "foo" })
         expect(actual).to eq(["foo", "default-b", "speed-of-light", 2.781])
       end
     end
 
     context "with the allowed number of args" do
       it "runs" do
-        invoke!("foo", "bar", "baz", e: "number4")
+        invoke!(args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4" })
         expect(actual).to eq(%w[foo bar baz number4])
       end
     end
 
-    context "with more than the allowed number of args" do
-      it "runs" do
-        invoke!("foo", "bar", "baz", "extra", e: "number4")
-        expect(actual).to be_a(::Simple::Service::ExtraArguments)
-      end
-    end
-
     context "with extra named args" do
       it "ignores extra args" do
-        invoke!("foo", "bar", "baz", e: "number4", extra3: 3)
+        invoke!(args: { "a" => "foo", "b" => "bar", "c" => "baz", "e" => "number4", "extra3" => 3 })
         expect(actual).to eq(["foo", "bar", "baz", "number4"])
       end
     end
@@ -237,30 +187,42 @@ describe "Simple::Service.invoke" do
 
     context "with the required number of args" do
       it "runs" do
-        invoke!("foo")
+        invoke!(args: { "a" => "foo" })
         expect(actual).to eq(["foo", "queen bee", [], 2.781])
       end
     end
 
     context "with the allowed number of args" do
       it "runs" do
-        invoke!("foo", "bar", "baz", e: "number4")
+        invoke!(args: { "a" => "foo", "b" => "bar", "args" => ["baz"] }, flags: { "e" => "number4" })
         expect(actual).to eq(["foo", "bar", ["baz"], "number4"])
       end
     end
 
-    context "with more than the allowed number of args" do
-      it "runs" do
-        invoke!("foo", "bar", "baz", "extra", e: "number4")
+    context "with variadic args" do
+      it "sends the variadic args from the args: parameter" do
+        invoke!(args: { "a" => "foo", "b" => "bar", "args" => ["baz", "extra"] }, flags: { "e" => "number4", "extra3" => 2 })
         expect(actual).to eq(["foo", "bar", ["baz", "extra"], "number4"])
       end
-    end
 
-    context "with extra named args" do
-      it "ignores extra args" do
-        invoke!("foo", "bar", "baz", e: "number4", extra3: 3)
-        expect(actual).to eq(["foo", "bar", ["baz"], "number4"])
+      it "sends the variadic args from the flags: parameter" do
+        invoke!(args: { "a" => "foo", "b" => "bar" }, flags: { "args" => ["baz", "extra"], "e" => "number4", "extra3" => 2 })
+        expect(actual).to eq(["foo", "bar", ["baz", "extra"], "number4"])
       end
     end
   end
+
+  describe "calling with symbolized Hashes" do
+    it "raises ArgumentError" do
+      hsh = { a: "foo", "b" => "KJH" }
+
+      expect do
+        invoke!(args: hsh)
+      end.to raise_error(Expectation::Matcher::Mismatch)
+
+      expect do
+        invoke!(flags: hsh)
+      end.to raise_error(Expectation::Matcher::Mismatch)
+    end
+  end
 end