simple-service 0.1.6 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 903d43626ea1853a44478fd58d6aef0a4e86374745e9a5732e127ab85fcd4437
-  data.tar.gz: ed5f2caa57468945b72bcf805c0ff3e2afd7df654ea03387a59fa16ea136ad19
+  metadata.gz: 6532ece44cb9ef6df3dab9073552ef9f35df38910395f76d9c0d67ec62bb56bc
+  data.tar.gz: a9d32157d67e9d97884ae46928183cba08c88b85157bc742e4632ea78d536efa
 SHA512:
-  metadata.gz: 0ab49e773b69b41e844a73da66f7ab06ca90f0d4edc097a4d44bc8457272040acd428fc37e3128a6e662f18bab30fb6d0e8a396c40eed6eccb2dd316171c5b1a
-  data.tar.gz: b06385441ec3d0ce87aba8095e30cb7ab07f871c6507ae133b611eab0f370458c378d5f1ffd27111221b3ca75096ca0ff41bc1c6b61ab1f40cfebe45b1a5ac81
+  metadata.gz: c70f870e322d3927d4cc4e23f7a71913e8a455ed0ddf8e157ab37d3b29017c3727f967e9457172daf282fd91d683585db23a1c515a203e60620a11cb0d0990a9
+  data.tar.gz: d73c6f4771642ff1c4a7237c5fa9528562894c20da8100f7097da33caee9a183683afa2b001fa0d9cd3becb09335de41054039ac1b37f273b5b130c33bd94403

data/.rubocop.yml

@@ -1,5 +1,6 @@
 AllCops:
-  TargetRubyVersion: 2.3
+  NewCops: enable
+  TargetRubyVersion: 2.7
   Exclude:
     - 'spec/**/*'
     - 'test/**/*'
@@ -14,7 +15,7 @@ Metrics/BlockLength:
   Exclude:
     - 'spec/**/*'
 
-Metrics/LineLength:
+Layout/LineLength:
   Max: 140
 
 Metrics/MethodLength:
@@ -101,3 +102,7 @@ Style/ParallelAssignment:
 
 Style/CommentedKeyword:
   Enabled: false
+
+Style/AccessorGrouping:
+  Enabled: false
+  

data/Gemfile

@@ -10,5 +10,7 @@ group :development, :test do
   gem 'rspec', '~> 3.7'
   # gem 'rubocop', '~> 0.61.1'
   gem 'simplecov', '~> 0'
-  gem 'byebug'
+  gem 'pry-byebug'
 end
+
+# gem "simple-immutable", "~> 1", path: "../simple-immutable"

data/VERSION

@@ -1 +1 @@
-0.1.6
+0.2.2

data/lib/simple/service/action/comment.rb

@@ -1,5 +1,3 @@
-# rubocop:disable Metrics/AbcSize
-
 # returns the comment for an action
 class ::Simple::Service::Action::Comment # @private
   attr_reader :short
@@ -8,7 +6,7 @@ class ::Simple::Service::Action::Comment # @private
   def self.extract(action:)
     file, line = action.source_location
     lines = Extractor.extract_comment_lines(file: file, before_line: line)
-    full = lines[2..-1].join("\n") if lines.length >= 2
+    full = lines[2..].join("\n") if lines.length >= 2
     new short: lines[0], full: full
   end
 

data/lib/simple/service/action.rb

@@ -1,4 +1,5 @@
 module Simple::Service
+  # rubocop:disable Lint/EmptyClass
   class Action
   end
 end
@@ -80,6 +81,12 @@ module Simple::Service
       positionals = build_positional_arguments(args, flags)
       keywords = build_keyword_arguments(args.merge(flags))
 
+      # check for extra flags
+      extra_flags = (flags.keys - keywords.keys.map(&:to_s)).map { |flag| "--#{flag}" }
+      unless extra_flags.empty?
+        raise Simple::Service::ArgumentError, "Unknown flag(s): #{extra_flags.join(", ")}."
+      end
+
       service_instance = Object.new
       service_instance.extend service
 
@@ -114,7 +121,7 @@ module Simple::Service
 
       # Note that +keys+ now only contains names of keyword arguments that actually exist.
       # This is therefore not a way to DOS this process.
-      Hash[keys.map(&:to_sym).zip(values)]
+      keys.map(&:to_sym).zip(values).to_h
     end
 
     def variadic_parameter
@@ -164,7 +171,7 @@ module Simple::Service
       # we otherwise raise a ExtraArguments exception.
       case ary.length <=> positional_names.length
       when 1  # i.e. ary.length > positional_names.length
-        extra_arguments = ary[positional_names.length..-1]
+        extra_arguments = ary[positional_names.length..]
         ary = ary[0..positional_names.length]
 
         if !extra_arguments.empty? && !variadic_parameter
@@ -179,7 +186,7 @@ module Simple::Service
       end
 
       # Build a hash with the existing_positional_names and the values from the array.
-      hsh = Hash[existing_positional_names.zip(ary)]
+      hsh = existing_positional_names.zip(ary).to_h
 
       # Add the variadic_parameter, if any.
       hsh[variadic_parameter.name] = extra_arguments if variadic_parameter

data/lib/simple/service/errors.rb

@@ -2,8 +2,10 @@ module Simple::Service
   # Will be raised by ::Simple::Service.action.
   class NoSuchAction < ::ArgumentError
     attr_reader :service, :name
+
     def initialize(service, name)
       @service, @name = service, name
+      super()
     end
 
     def to_s
@@ -22,6 +24,7 @@ module Simple::Service
 
     def initialize(action, parameters)
       @action, @parameters = action, parameters
+      super()
     end
 
     def to_s
@@ -35,6 +38,7 @@ module Simple::Service
 
     def initialize(action, arguments)
       @action, @arguments = action, arguments
+      super()
     end
 
     def to_s
@@ -43,9 +47,6 @@ module Simple::Service
     end
   end
 
-  class ContextMissingError < ::StandardError
-  end
-
   class ContextReadOnlyError < ::StandardError
     def initialize(key)
       super "Cannot overwrite existing context setting #{key.inspect}"

data/lib/simple/service.rb

@@ -1,12 +1,14 @@
 module Simple # @private
 end
 
+module Simple::Service # @private
+end
+
 require "expectation"
 require "logger"
 
 require_relative "service/errors"
 require_relative "service/action"
-require_relative "service/context"
 require_relative "service/version"
 
 # <b>The Simple::Service interface</b>
@@ -40,11 +42,9 @@ require_relative "service/version"
 # TODO: why a Hash? It feels much better if Simple::Service.actions returns an array of names.
 #
 #
-# 3. <em>Invoke a service:</em> run <tt>Simple::Service.invoke3</tt> or <tt>Simple::Service.invoke</tt>. You must set a context first.
+# 3. <em>Invoke a service:</em> run <tt>Simple::Service.invoke3</tt> or <tt>Simple::Service.invoke</tt>.
 #
-#     Simple::Service.with_context do
-#       Simple::Service.invoke3(GodMode, :build_universe, "TestWorld", c: 1e9)
-#     end
+#     Simple::Service.invoke3(GodMode, :build_universe, "TestWorld", c: 1e9)
 #     => 42
 #
 module Simple::Service
@@ -61,28 +61,16 @@ module Simple::Service
     klass.include ServiceExpectations
   end
 
-  def self.logger
-    @logger ||= ::Logger.new(STDOUT)
-  end
-
-  def self.logger=(logger)
-    @logger = logger
-  end
-
-  # returns true if the passed in object is a service module.
-  #
-  # A service must be a module, and it must include the Simple::Service module.
-  def self.service?(service)
-    verify_service! service
-    true
-  rescue ::ArgumentError
-    false
-  end
-
-  # Raises an error if the passed in object is not a service
+  # Raises an error if the passed in object is not a Simple::Service
   def self.verify_service!(service) # @private
-    raise ::ArgumentError, "#{service.inspect} must be a Simple::Service, but is not even a Module" unless service.is_a?(Module)
-    raise ::ArgumentError, "#{service.inspect} must be a Simple::Service, did you 'include Simple::Service'" unless service.include?(self)
+    expect! service => Module
+
+    # rubocop:disable Style/GuardClause
+    unless service.include?(::Simple::Service)
+      raise ::ArgumentError,
+            "#{service.name} is not a Simple::Service, did you 'include Simple::Service'"
+    end
+    # rubocop:enable Style/GuardClause
   end
 
   # returns a Hash with all actions in the +service+ module
@@ -94,6 +82,8 @@ module Simple::Service
 
   # returns the action with the given name.
   def self.action(service, name)
+    expect! name => Symbol
+
     actions = self.actions(service)
     actions[name] || begin
       raise ::Simple::Service::NoSuchAction.new(service, name)
@@ -107,10 +97,8 @@ module Simple::Service
   #
   # As the main purpose of this module is to call services with outside data,
   # the +.invoke+ action is usually preferred.
-  #
-  # *Note:* You cannot call this method if the context is not set.
   def self.invoke3(service, name, *args, **flags)
-    flags = flags.each_with_object({}) { |(k, v), hsh| hsh[k.to_s] = v }
+    flags = flags.transform_keys(&:to_s)
     invoke service, name, args: args, flags: flags
   end
 
@@ -154,14 +142,10 @@ module Simple::Service
   # by the method we raise an ArgumentError.
   #
   # Entries in the +named_args+ Hash that are not defined in the action itself are ignored.
-
-  # <b>Note:</b> You cannot call this method if the context is not set.
   def self.invoke(service, name, args: {}, flags: {})
-    raise ContextMissingError, "Need to set context before calling ::Simple::Service.invoke3" unless context
-
     expect! args => [Hash, Array], flags: Hash
-    args.keys.each { |key| expect! key => String } if args.is_a?(Hash)
-    flags.keys.each { |key| expect! key => String }
+    args.each_key { |key| expect! key => String } if args.is_a?(Hash)
+    flags.each_key { |key| expect! key => String }
 
     action(service, name).invoke(args: args, flags: flags)
   end

data/lib/simple/workflow/context.rb

@@ -0,0 +1,105 @@
+require "simple/immutable"
+
+module Simple::Workflow
+  # A context object
+  #
+  # Each service executes with a current context. The system manages a stack of
+  # contexts; whenever a service execution is done the current context is reverted
+  # to its previous value.
+  #
+  # A context object can store a large number of values; the only way to set or
+  # access a value is via getters and setters. These are implemented via
+  # +method_missing(..)+.
+  #
+  # Also, once a value is set in the context it is not possible to change or
+  # unset it.
+  class Context < Simple::Immutable
+    SELF = self
+
+    # returns a new Context object.
+    #
+    # Parameters:
+    #
+    # - hsh (Hash or nil): sets values for this context
+    # - previous_context (Context or nil): if +previous_context+ is provided,
+    #   values that are not defined in the \a +hsh+ argument are read from the
+    #   +previous_context+ instead (or the previous context's +previous_context+,
+    #   etc.)
+    def initialize(hsh, previous_context = nil)
+      expect! hsh => [Hash, nil]
+      expect! previous_context => [SELF, nil]
+
+      @previous_context = previous_context
+      super(hsh || {})
+    end
+
+    def reload!(a_module)
+      if @previous_context
+        @previous_context.reload!(a_module)
+        return a_module
+      end
+
+      @reloaded_modules ||= []
+      return if @reloaded_modules.include?(a_module)
+
+      ::Simple::Workflow::Reloader.reload(a_module)
+      @reloaded_modules << a_module
+      a_module
+    end
+
+    def fetch_attribute!(sym, raise_when_missing:)
+      unless @previous_context
+        return super(sym, raise_when_missing: raise_when_missing)
+      end
+
+      first_error = nil
+
+      # check this context first. We catch any NameError, to be able to look up
+      # the attribute also in the previous_context.
+      begin
+        return super(sym, raise_when_missing: true)
+      rescue NameError => e
+        first_error = e
+      end
+
+      # check previous_context
+      begin
+        return @previous_context.fetch_attribute!(sym, raise_when_missing: raise_when_missing)
+      rescue NameError
+        :nop
+      end
+
+      # Not in +self+, not in +previous_context+, and +raise_when_missing+ is true:
+      raise(first_error)
+    end
+
+    # def inspect
+    #   if @previous_context
+    #     "#{object_id} [" + @hsh.keys.map(&:inspect).join(", ") + "; #{@previous_context.inspect}]"
+    #   else
+    #     "#{object_id} [" + @hsh.keys.map(&:inspect).join(", ") + "]"
+    #   end
+    # end
+
+    private
+
+    IDENTIFIER = "[a-z_][a-z0-9_]*" # @private
+
+    def method_missing(sym, *args, &block)
+      raise ArgumentError, "#{self.class.name}##{sym}: Block given" if block
+      raise ArgumentError, "#{self.class.name}##{sym}: Extra args #{args.inspect}" unless args.empty?
+
+      if sym !~ /\A(#{IDENTIFIER})(\?)?\z/
+        raise ArgumentError, "#{self.class.name}: Invalid context key '#{sym}'"
+      end
+
+      # rubocop:disable Lint/OutOfRangeRegexpRef
+      fetch_attribute!($1, raise_when_missing: $2.nil?)
+      # rubocop:enable Lint/OutOfRangeRegexpRef
+    end
+
+    def respond_to_missing?(sym, include_private = false)
+      super || @previous_context&.respond_to_missing?(sym, include_private)
+    end
+  end
+end

data/lib/simple/workflow/current_context.rb

@@ -0,0 +1,33 @@
+module Simple::Workflow
+  module CurrentContext
+    # Returns the current context.
+    #
+    # This method never returns nil - it raises a ContextMissingError exception if
+    # the context was not initialized (via <tt>Simple::Workflow.with_context</tt>).
+    def current_context
+      Thread.current[:"Simple::Workflow.current_context"] || raise(ContextMissingError)
+    end
+
+    # Returns a logger
+    #
+    # Returns a logger if a context is set and contains a logger.
+    def logger
+      current_context = Thread.current[:"Simple::Workflow.current_context"]
+      current_context&.logger?
+    end
+
+    # yields a block with a given context, and restores the previous context
+    # object afterwards.
+    def with_context(ctx = nil, &block)
+      old_ctx = Thread.current[:"Simple::Workflow.current_context"]
+
+      Thread.current[:"Simple::Workflow.current_context"] = Context.new(ctx, old_ctx)
+
+      block.call
+    ensure
+      Thread.current[:"Simple::Workflow.current_context"] = old_ctx
+    end
+  end
+
+  extend CurrentContext
+end

data/lib/simple/workflow/reloader.rb

@@ -0,0 +1,84 @@
+# The Simple::Workflow::Reloader provides a way to locate and reload a module
+module Simple::Workflow::Reloader
+  extend self
+
+  def reload(a_module)
+    source_paths = locate(a_module)
+    if source_paths.empty?
+      logger&.warn "#{a_module}: cannot reload module: cannot find sources"
+      return
+    end
+
+    source_paths.each do |source_path|
+      logger&.debug "#{a_module}: reload #{source_path}"
+    end
+
+    logger&.info "#{a_module}: reloaded module"
+  end
+
+  # This method tries to identify source files for a module's functions.
+  def locate(a_module)
+    expect! a_module => Module
+
+    @registered_source_paths ||= {}
+    @registered_source_paths[a_module.name] ||= locate_source_paths(a_module)
+  end
+
+  private
+
+  def logger
+    ::Simple::Workflow.logger
+  end
+
+  def locate_source_paths(a_module)
+    source_paths = []
+
+    source_paths.concat locate_by_instance_methods(a_module)
+    source_paths.concat locate_by_methods(a_module)
+    source_paths.concat locate_by_name(a_module)
+
+    source_paths.uniq
+  end
+
+  def locate_by_instance_methods(a_module)
+    method_names = a_module.instance_methods(false)
+    methods = method_names.map { |sym| a_module.instance_method(sym) }
+    methods.map(&:source_location).map(&:first)
+  end
+
+  def locate_by_methods(a_module)
+    method_names = a_module.methods(false)
+    methods = method_names.map { |sym| a_module.method(sym) }
+    methods.map(&:source_location).map(&:first)
+  end
+
+  def locate_by_name(a_module)
+    source_file = "#{underscore(a_module.name)}.rb"
+
+    $LOAD_PATH.each do |dir|
+      full_path = File.join(dir, source_file)
+      return [full_path] if File.exist?(full_path)
+    end
+
+    []
+  end
+
+  # Makes an underscored, lowercase form from the expression in the string.
+  #
+  # Changes '::' to '/' to convert namespaces to paths.
+  #
+  # This is copied and slightly changed (we don't support any custom
+  # inflections) from activesupport's  lib/active_support/inflector/methods.rb
+  #
+  def underscore(camel_cased_word)
+    return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
+
+    word = camel_cased_word.to_s.gsub("::", "/")
+
+    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+end

data/lib/simple/workflow/rspec_helper.rb

@@ -0,0 +1,15 @@
+module ::Simple::Workflow::RSpecHelper
+  def self.included(base)
+    base.let(:current_context) { {} }
+
+    base.around do |example|
+      if (ctx = current_context)
+        ::Simple::Workflow.with_context(ctx) do
+          example.run
+        end
+      else
+        example.run
+      end
+    end
+  end
+end

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

@@ -19,7 +19,8 @@ Gem::Specification.new do |gem|
   # executables are used for development purposes only
   gem.executables   = []
 
-  gem.required_ruby_version = '~> 2.5'
+  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

@@ -3,14 +3,6 @@
 require "spec_helper"
 
 describe "Simple::Service.invoke3" 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 }
 

data/spec/simple/service/action_invoke_spec.rb

@@ -1,16 +1,7 @@
 # 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 }
 

data/spec/simple/service/service_spec.rb

@@ -6,12 +6,6 @@ describe "Simple::Service" do
   context "when running against a NoService module" do
     let(:service) { NoServiceModule }
 
-    describe ".service?" do
-      it "returns false on a NoService module" do
-        expect(Simple::Service.service?(service)).to eq(false)
-      end
-    end
-
     describe ".actions" do
       it "raises an argument error" do
         expect { Simple::Service.actions(service) }.to raise_error(ArgumentError)
@@ -26,9 +20,7 @@ describe "Simple::Service" do
 
     describe ".invoke3" do
       it "raises an argument error" do
-        ::Simple::Service.with_context do
-          expect { Simple::Service.invoke3(service, :service1, {}, {}, context: nil) }.to raise_error(::ArgumentError)
-        end
+        expect { Simple::Service.invoke3(service, :service1, {}, {}, context: nil) }.to raise_error(::ArgumentError)
       end
     end
   end
@@ -36,12 +28,6 @@ describe "Simple::Service" do
   # running against a proper service module
   let(:service) { SpecService }
 
-  describe ".service?" do
-    it "returns true" do
-      expect(Simple::Service.service?(service)).to eq(true)
-    end
-  end
-
   describe ".actions" do
     it "returns a Hash of actions on a Service module" do
       actions = Simple::Service.actions(service)
@@ -83,26 +69,11 @@ describe "Simple::Service" do
       Simple::Service.invoke3(service, :service1, "my_a", "my_b", d: "my_d")
     end
 
-    context "when context is not set" do
-      it "raises a ContextMissingError" do
-        action = Simple::Service.actions(service)[:service1]
-        expect(action).not_to receive(:invoke)
-
-        expect do
-          invoke3
-        end.to raise_error(::Simple::Service::ContextMissingError)
-      end
-    end
-
-    context "when context is set" do
-      it "calls Action#invoke with the right arguments" do
-        action = Simple::Service.actions(service)[:service1]
-        expect(action).to receive(:invoke).with(args: ["my_a", "my_b"], flags: { "d" => "my_d" })
+    it "calls Action#invoke with the right arguments" do
+      action = Simple::Service.actions(service)[:service1]
+      expect(action).to receive(:invoke).with(args: ["my_a", "my_b"], flags: { "d" => "my_d" })
 
-        ::Simple::Service.with_context do
-          invoke3
-        end
-      end
+      invoke3
     end
   end
 
@@ -112,26 +83,11 @@ describe "Simple::Service" do
         Simple::Service.invoke(service, :service1, args: ["my_a", "my_b"], flags: { "d" => "my_d" })
       end
 
-      context "when context is not set" do
-        it "raises a ContextMissingError" do
-          action = Simple::Service.actions(service)[:service1]
-          expect(action).not_to receive(:invoke)
-
-          expect do
-            invoke
-          end.to raise_error(::Simple::Service::ContextMissingError)
-        end
-      end
-
-      context "when context is set" do
-        it "calls Action#invoke with the right arguments" do
-          action = Simple::Service.actions(service)[:service1]
-          expect(action).to receive(:invoke).with(args: ["my_a", "my_b"], flags: { "d" => "my_d" }).and_call_original
+      it "calls Action#invoke with the right arguments" do
+        action = Simple::Service.actions(service)[:service1]
+        expect(action).to receive(:invoke).with(args: ["my_a", "my_b"], flags: { "d" => "my_d" }).and_call_original
 
-          ::Simple::Service.with_context do
-            invoke
-          end
-        end
+        invoke
       end
     end
   end
@@ -147,12 +103,11 @@ describe "Simple::Service" do
 
     it "calls Action#invoke with the right arguments" do
       expected = ["bar-value", "baz-value"]
-      ::Simple::Service.with_context do
-        expect(invoke3("bar-value", baz: "baz-value")).to eq(expected)
-        expect(invoke3(bar: "bar-value", baz: "baz-value")).to eq(expected)
-        expect(invoke(args: ["bar-value"], flags: { "baz" => "baz-value" })).to eq(expected)
-        expect(invoke(args: { "bar" => "bar-value", "baz" => "baz-value" })).to eq(expected)
-      end
+
+      expect(invoke3("bar-value", baz: "baz-value")).to eq(expected)
+      expect(invoke3(bar: "bar-value", baz: "baz-value")).to eq(expected)
+      expect(invoke(args: ["bar-value"], flags: { "baz" => "baz-value" })).to eq(expected)
+      expect(invoke(args: { "bar" => "bar-value", "baz" => "baz-value" })).to eq(expected)
     end
   end
 end

data/spec/simple/workflow/context_spec.rb

@@ -0,0 +1,90 @@
+require "spec_helper"
+
+describe Simple::Workflow::Context do
+  RSpec.shared_examples "context requesting" do
+    it "inherits from Simple::Immutable" do
+      expect(context).to be_a(Simple::Immutable)
+    end
+
+    describe "checking for identifier" do
+      it "raises an ArgumentError if the key is invalid" do
+        expect { context.oneTwoThree? }.to raise_error(ArgumentError)
+      end
+
+      it "returns nil if the key is not set" do
+        expect(context.two?).to be_nil
+      end
+
+      it "returns the value if the key is set" do
+        expect(context.one?).to eq 1
+      end
+    end
+
+    describe "fetching identifier" do
+      it "raises an ArgumentError if the identifier is invalid" do
+        expect { context.one! }.to raise_error(ArgumentError)
+        expect { context.oneTwoThree }.to raise_error(ArgumentError)
+      end
+
+      it "raises a NoMethodError if the key is not set" do
+        expect { context.two }.to raise_error(NameError)
+      end
+
+      it "returns the value if the key is set" do
+        expect(context.one).to eq 1
+      end
+    end
+
+    describe "#merge" do
+      context "with symbolized keys" do
+        it "sets a value if it does not exist yet" do
+          expect(context.two?).to eq(nil)
+          new_context = Simple::Workflow::Context.new({two: 2}, context)
+          expect(new_context.two).to eq(2)
+
+          # doesn't change the source context
+          expect(context.two?).to eq(nil)
+        end
+
+        it "sets a value if it does exist" do
+          new_context = Simple::Workflow::Context.new({one: 2}, context)
+          expect(new_context.one).to eq(2)
+
+          # doesn't change the source context
+          expect(context.one).to eq(1)
+        end
+      end
+
+      context "with stringified keys" do
+        it "sets a value if it does not exist yet" do
+          expect(context.two?).to eq(nil)
+          new_context = Simple::Workflow::Context.new({"two" => 2}, context)
+          expect(new_context.two).to eq(2)
+
+          # doesn't change the source context
+          expect(context.two?).to eq(nil)
+        end
+
+        it "sets a value if it does exist" do
+          new_context = Simple::Workflow::Context.new({"one" => 2}, context)
+          expect(new_context.one).to eq(2)
+
+          # doesn't change the source context
+          expect(context.one).to eq(1)
+        end
+      end
+    end
+  end
+
+  context "with a symbolized context" do
+    let(:context) { Simple::Workflow::Context.new(one: 1) }
+
+    it_behaves_like "context requesting"
+  end
+
+  context "with a stringified context" do
+    let(:context) { Simple::Workflow::Context.new("one" => 1) }
+
+    it_behaves_like "context requesting"
+  end
+end

data/spec/simple/workflow/current_context_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe Simple::Workflow::CurrentContext do
+  describe ".with_context" do
+    it "merges the current context for the duration of the block" do
+      block_called = false
+
+      Simple::Workflow.with_context(a: "a", foo: "bar") do
+        expect(Simple::Workflow.current_context.a).to eq("a")
+        expect(Simple::Workflow.current_context.foo).to eq("bar")
+
+        # layering
+        Simple::Workflow.with_context() do
+          expect(Simple::Workflow.current_context.foo).to eq("bar")
+
+          expect(Simple::Workflow.current_context.unknown?).to be_nil
+          expect {
+            Simple::Workflow.current_context.unknown
+          }.to raise_error(NameError)
+        end
+
+        # overwrite value
+        Simple::Workflow.with_context(a: "b") do
+          expect(Simple::Workflow.current_context.a).to eq("b")
+          block_called = true
+        end
+
+        # overwrite value w/nil
+        Simple::Workflow.with_context(a: nil) do
+          expect(Simple::Workflow.current_context.a).to be_nil
+          Simple::Workflow.with_context(a: "c") do
+            expect(Simple::Workflow.current_context.a).to eq("c")
+          end
+        end
+        expect(Simple::Workflow.current_context.a).to eq("a")
+      end
+
+      expect(block_called).to eq(true)
+    end
+  end
+end

data/spec/simple/workflow/reloader_spec/example1.rb

@@ -0,0 +1,10 @@
+module ReloaderSpecExample1
+  def foo; end
+end
+
+module ReloaderSpecExample2
+end
+
+module ReloaderSpecExample3
+  def foo; end
+end

data/spec/simple/workflow/reloader_spec/example2.rb

@@ -0,0 +1,7 @@
+module ReloaderSpecExample1
+  def self.bar; end
+end
+
+module ReloaderSpecExample2
+  def self.bar; end
+end

data/spec/simple/workflow/reloader_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+require_relative "reloader_spec/example1"
+require_relative "reloader_spec/example2"
+
+describe "Simple::Service::Reloader" do
+  describe ".locate" do
+    def locate(mod)
+      Simple::Workflow::Reloader.locate(mod)
+    end
+
+    it "Returns all source files of a module" do
+      root = Dir.getwd
+
+      expected = [
+        "#{root}/lib/simple/workflow/reloader.rb"
+      ]
+      expect(locate(Simple::Workflow::Reloader)).to contain_exactly(*expected)
+
+      expected = [
+        "#{__dir__}/reloader_spec/example1.rb",
+        "#{__dir__}/reloader_spec/example2.rb"
+      ]
+      expect(locate(ReloaderSpecExample1)).to contain_exactly(*expected)
+
+      expected = [
+        "#{__dir__}/reloader_spec/example2.rb"
+      ]
+      expect(locate(ReloaderSpecExample2)).to contain_exactly(*expected)
+
+      expected = [
+        "#{__dir__}/reloader_spec/example1.rb"
+      ]
+      expect(locate(ReloaderSpecExample3)).to contain_exactly(*expected)
+    end
+  end
+
+  describe ".reload" do
+    def reload(mod)
+      Simple::Workflow::Reloader.reload(mod)
+    end
+
+    it "Reloads a module" do
+      # [TODO] this doesn't really check reloading...
+      reload Simple::Workflow::Reloader
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 ENV["RACK_ENV"] = "test"
 ENV["RAILS_ENV"] = "test"
 
-require "byebug"
+require "pry-byebug"
 require "rspec"
 
 require "simplecov"
@@ -18,6 +18,7 @@ SimpleCov.start do
 end
 
 require "simple/service"
+require "simple/workflow"
 
 Dir.glob("./spec/support/**/*.rb").sort.each { |path| load path }
 

data/spec/support/spec_services.rb

@@ -1,5 +1,3 @@
-# rubocop:disable Naming/UncommunicativeMethodParamName
-
 module NoServiceModule
 end
 
@@ -53,6 +51,6 @@ module SpecTestService
   include Simple::Service
 
   def foo(bar, baz:)
-    [ bar, baz ]
+    [bar, baz]
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple-service
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.2
 platform: ruby
 authors:
 - radiospiel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-25 00:00:00.000000000 Z
+date: 2022-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: expectation
@@ -24,6 +24,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
+- !ruby/object:Gem::Dependency
+  name: simple-immutable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
 description: Pretty simple and somewhat abstract service description
 email: eno@radiospiel.org
 executables: []
@@ -75,26 +95,36 @@ files:
 - doc/method_list.html
 - doc/top-level-namespace.html
 - lib/simple-service.rb
+- lib/simple-workflow.rb
 - lib/simple/service.rb
 - lib/simple/service/action.rb
 - lib/simple/service/action/comment.rb
 - lib/simple/service/action/method_reflection.rb
 - lib/simple/service/action/parameter.rb
-- lib/simple/service/context.rb
 - lib/simple/service/errors.rb
 - lib/simple/service/version.rb
+- lib/simple/workflow.rb
+- lib/simple/workflow/context.rb
+- lib/simple/workflow/current_context.rb
+- lib/simple/workflow/reloader.rb
+- lib/simple/workflow/rspec_helper.rb
 - log/.gitkeep
 - scripts/release
 - scripts/release.rb
 - scripts/stats
+- scripts/test
 - scripts/watch
 - simple-service.gemspec
 - spec/simple/service/action_invoke3_spec.rb
 - spec/simple/service/action_invoke_spec.rb
 - spec/simple/service/action_spec.rb
-- spec/simple/service/context_spec.rb
 - spec/simple/service/service_spec.rb
 - spec/simple/service/version_spec.rb
+- spec/simple/workflow/context_spec.rb
+- spec/simple/workflow/current_context_spec.rb
+- spec/simple/workflow/reloader_spec.rb
+- spec/simple/workflow/reloader_spec/example1.rb
+- spec/simple/workflow/reloader_spec/example2.rb
 - spec/spec_helper.rb
 - spec/support/spec_services.rb
 homepage: http://github.com/radiospiel/simple-service
@@ -106,7 +136,7 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
@@ -115,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Pretty simple and somewhat abstract service description
@@ -123,8 +153,12 @@ test_files:
 - spec/simple/service/action_invoke3_spec.rb
 - spec/simple/service/action_invoke_spec.rb
 - spec/simple/service/action_spec.rb
-- spec/simple/service/context_spec.rb
 - spec/simple/service/service_spec.rb
 - spec/simple/service/version_spec.rb
+- spec/simple/workflow/context_spec.rb
+- spec/simple/workflow/current_context_spec.rb
+- spec/simple/workflow/reloader_spec.rb
+- spec/simple/workflow/reloader_spec/example1.rb
+- spec/simple/workflow/reloader_spec/example2.rb
 - spec/spec_helper.rb
 - spec/support/spec_services.rb

data/lib/simple/service/context.rb

@@ -1,94 +0,0 @@
-module Simple::Service
-  # Returns the current context.
-  def self.context
-    Thread.current[:"Simple::Service.context"]
-  end
-
-  # yields a block with a given context, and restores the previous context
-  # object afterwards.
-  def self.with_context(ctx = nil, &block)
-    old_ctx = Thread.current[:"Simple::Service.context"]
-    new_ctx = old_ctx ? old_ctx.merge(ctx) : Context.new(ctx)
-
-    Thread.current[:"Simple::Service.context"] = new_ctx
-
-    block.call
-  ensure
-    Thread.current[:"Simple::Service.context"] = old_ctx
-  end
-end
-
-module Simple::Service
-  # A context object
-  #
-  # Each service executes with a current context. The system manages a stack of
-  # contexts; whenever a service execution is done the current context is reverted
-  # to its previous value.
-  #
-  # A context object can store a large number of values; the only way to set or
-  # access a value is via getters and setters. These are implemented via
-  # +method_missing(..)+.
-  #
-  # Also, once a value is set in the context it is not possible to change or
-  # unset it.
-  class Context
-    def initialize(hsh = nil) # @private
-      @hsh = hsh || {}
-    end
-
-    # returns a new Context object, which merges the values in the +overlay+
-    # argument (which must be a Hash or nil) with the values in this context.
-    #
-    # The overlay is allowed to change values in the current context.
-    #
-    # It does not change this context.
-    def merge(overlay)
-      expect! overlay => [Hash, nil]
-
-      overlay ||= {}
-      new_context_hsh = @hsh.merge(overlay)
-      ::Simple::Service::Context.new(new_context_hsh)
-    end
-
-    private
-
-    IDENTIFIER_PATTERN = "[a-z][a-z0-9_]*" # @private
-    IDENTIFIER_REGEXP = Regexp.compile("\\A#{IDENTIFIER_PATTERN}\\z") # @private
-    ASSIGNMENT_REGEXP = Regexp.compile("\\A(#{IDENTIFIER_PATTERN})=\\z") # @private
-
-    def method_missing(sym, *args, &block)
-      raise ArgumentError, "Block given" if block
-
-      if args.count == 0 && sym =~ IDENTIFIER_REGEXP
-        self[sym]
-      elsif args.count == 1 && sym =~ ASSIGNMENT_REGEXP
-        self[$1.to_sym] = args.first
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(sym, include_private = false)
-      # :nocov:
-      return true if IDENTIFIER_REGEXP.match?(sym)
-      return true if ASSIGNMENT_REGEXP.match?(sym)
-
-      super
-      # :nocov:
-    end
-
-    def [](key)
-      @hsh[key]
-    end
-
-    def []=(key, value)
-      existing_value = @hsh[key]
-
-      unless existing_value.nil? || existing_value == value
-        raise ::Simple::Service::ContextReadOnlyError, key
-      end
-
-      @hsh[key] = value
-    end
-  end
-end

data/spec/simple/service/context_spec.rb

@@ -1,69 +0,0 @@
-require "spec_helper"
-
-describe Simple::Service do
-  describe ".with_context" do
-    it "merges the current context for the duration of the block" do
-      block_called = false
-
-      Simple::Service.with_context(a: "a") do
-        expect(Simple::Service.context.a).to eq("a")
-
-        # overwrite value
-        Simple::Service.with_context(a: "b") do
-          expect(Simple::Service.context.a).to eq("b")
-          block_called = true
-        end
-
-        # overwrite value w/nil
-        Simple::Service.with_context(a: nil) do
-          expect(Simple::Service.context.a).to be_nil
-          Simple::Service.context.a = "c"
-          expect(Simple::Service.context.a).to eq("c")
-        end
-        expect(Simple::Service.context.a).to eq("a")
-      end
-
-      expect(block_called).to eq(true)
-    end
-  end
-end
-
-describe Simple::Service::Context do
-  let(:context) { Simple::Service::Context.new }
-
-  before do
-    context.one = 1
-  end
-
-  describe "invalid identifier" do
-    it "raises an error" do
-      expect { context.one! }.to raise_error(NoMethodError)
-    end
-  end
-
-  describe "context reading" do
-    it "returns a value if set" do
-      expect(context.one).to eq(1)
-    end
-
-    it "returns nil if not set" do
-      expect(context.two).to be_nil
-    end
-  end
-
-  describe "context writing" do
-    it "sets a value if it does not exist yet" do
-      context.two = 2
-      expect(context.two).to eq(2)
-    end
-
-    it "raises a ReadOnly error if the value exists and is not equal" do
-      expect { context.one = 2 }.to raise_error(::Simple::Service::ContextReadOnlyError)
-    end
-
-    it "sets the value if it exists and is equal" do
-      context.one = 1
-      expect(context.one).to eq(1)
-    end
-  end
-end