simple-service 0.1.1 → 0.1.2

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

@@ -1,5 +1,5 @@
 # returns the comment for an action
-class ::Simple::Service::Action::Comment
+class ::Simple::Service::Action::Comment # :nodoc:
   attr_reader :short
   attr_reader :full
 

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

@@ -16,7 +16,7 @@ module ::Simple::Service::Action::MethodReflection # :nodoc:
     method = service.instance_method(method_id)
     parameters = method.parameters
 
-    # method parameters with a :key mode are optional keyword arguments. We only
+    # method parameters with a :key mode are optional named arguments. We only
     # support defaults for those - if there are none we abort here already.
     keys = parameters.map { |mode, name| name if mode == :key }.compact
     return parameters if keys.empty?
@@ -59,7 +59,7 @@ module ::Simple::Service::Action::MethodReflection # :nodoc:
     # values for these arguments doesn't matter at all.
     args = method.parameters.select { |mode, _name| mode == :req }
 
-    # Add a hash with all required keyword arguments
+    # Add a hash with all required named arguments
     required_keyword_args = method.parameters.each_with_object({}) do |(mode, name), hsh|
       hsh[name] = :anything if mode == :keyreq
     end

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

@@ -7,10 +7,10 @@ class ::Simple::Service::Action::Parameter
   end
 
   def keyword?
-    [:key, :keyreq].include? @kind
+    [:keyreq, :key].include? @kind
   end
 
-  def anonymous?
+  def positional?
     [:req, :opt].include? @kind
   end
 
@@ -22,10 +22,6 @@ class ::Simple::Service::Action::Parameter
     @kind == :rest
   end
 
-  def optional?
-    !required?
-  end
-
   attr_reader :name
   attr_reader :kind
 

data/lib/simple/service/context.rb

@@ -1,39 +1,65 @@
 module Simple::Service
-  class Context
-    class ReadOnlyError < RuntimeError
-      def initialize(key)
-        super "Cannot overwrite existing context setting #{key.inspect}"
-      end
-    end
+  # Returns the current context.
+  def self.context
+    Thread.current[:"Simple::Service.context"]
+  end
 
-    def initialize
-      @hsh = {}
-    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)
 
-    private
+    Thread.current[:"Simple::Service.context"] = new_ctx
 
-    def [](key)
-      @hsh[key]
-    end
+    block.call
+  ensure
+    Thread.current[:"Simple::Service.context"] = old_ctx
+  end
+end
 
-    def []=(key, value)
-      existing_value = @hsh[key]
+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 = {}) # :nodoc:
+      @hsh = hsh
+    end
 
-      unless existing_value.nil? || existing_value == value
-        raise ReadOnlyError, key
-      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]
 
-      @hsh[key] = value
+      overlay ||= {}
+      new_context_hsh = @hsh.merge(overlay)
+      ::Simple::Service::Context.new(new_context_hsh)
     end
 
-    IDENTIFIER_PATTERN = "[a-z][a-z0-9_]*"
-    IDENTIFIER_REGEXP = Regexp.compile("\\A#{IDENTIFIER_PATTERN}\\z")
-    ASSIGNMENT_REGEXP = Regexp.compile("\\A(#{IDENTIFIER_PATTERN})=\\z")
+    private
+
+    IDENTIFIER_PATTERN = "[a-z][a-z0-9_]*" # :nodoc:
+    IDENTIFIER_REGEXP = Regexp.compile("\\A#{IDENTIFIER_PATTERN}\\z") # :nodoc:
+    ASSIGNMENT_REGEXP = Regexp.compile("\\A(#{IDENTIFIER_PATTERN})=\\z") # :nodoc:
 
     def method_missing(sym, *args, &block)
-      if block
-        super
-      elsif args.count == 0 && sym =~ IDENTIFIER_REGEXP
+      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
@@ -43,10 +69,26 @@ module Simple::Service
     end
 
     def respond_to_missing?(sym, include_private = false)
-      return true if IDENTIFIER_REGEXP.maptch?(sym)
-      return true if ASSIGNMENT_REGEXP.maptch?(sym)
+      # :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/lib/simple/service/errors.rb

@@ -0,0 +1,54 @@
+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
+    end
+
+    def to_s
+      action_names = ::Simple::Service.actions(service).keys.sort
+      informal = "service #{service} has these actions: #{action_names.map(&:inspect).join(", ")}"
+      "No such action #{name.inspect}; #{informal}"
+    end
+  end
+
+  class ArgumentError < ::ArgumentError
+  end
+
+  class MissingArguments < ArgumentError
+    attr_reader :action
+    attr_reader :parameters
+
+    def initialize(action, parameters)
+      @action, @parameters = action, parameters
+    end
+
+    def to_s
+      "#{action}: missing argument(s): #{parameters.map(&:to_s).join(", ")}"
+    end
+  end
+
+  class ExtraArguments < ArgumentError
+    attr_reader :action
+    attr_reader :arguments
+
+    def initialize(action, arguments)
+      @action, @arguments = action, arguments
+    end
+
+    def to_s
+      str = @arguments.map(&:inspect).join(", ")
+      "#{action}: extra argument(s) #{str}"
+    end
+  end
+
+  class ContextMissingError < ::StandardError
+  end
+
+  class ContextReadOnlyError < ::StandardError
+    def initialize(key)
+      super "Cannot overwrite existing context setting #{key.inspect}"
+    end
+  end
+end

data/lib/simple/service/version.rb

@@ -1,5 +1,8 @@
-class Simple::Service
-  module GemHelper
+module Simple # :nodoc:
+end
+
+module Simple::Service
+  module GemHelper # :nodoc:
     extend self
 
     def version(name)
@@ -14,9 +17,11 @@ class Simple::Service
     def unreleased?(spec)
       return false unless defined?(Bundler::Source::Gemspec)
       return true if spec.source.is_a?(::Bundler::Source::Gemspec)
+      # :nocov:
       return true if spec.source.is_a?(::Bundler::Source::Path)
 
       false
+      # :nocov:
     end
   end
 

data/scripts/stats

@@ -1,4 +1,5 @@
 #!/bin/bash
 
-cloc $(find lib/ -name *rb) | grep -E 'Language|Ruby' | sed 's-Language-        -'
+# cloc $(find lib/ -name *rb) | grep -E 'Language|Ruby' | sed 's-Language-        -'
+cloc --by-file --docstring-as-code --quiet --hide-rate $(find lib/ -name *rb)
 printf "\n"

data/spec/simple/service/action_invoke2_spec.rb

@@ -0,0 +1,166 @@
+# rubocop:disable Style/WordArray
+
+require "spec_helper"
+
+describe "Simple::Service.invoke2" 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 invoke2!(**hsh)
+    @actual = ::Simple::Service.invoke2(service, action, args: hsh)
+    # rescue ::StandardError => e
+  rescue ::Simple::Service::ArgumentError => e
+    @actual = e
+  end
+
+  attr_reader :actual
+
+  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
+        invoke2!
+        expect(actual).to eq("service2 return")
+      end
+    end
+
+    context "calling with extra named args" do
+      it "ignores extra args" do
+        invoke2!(foo: "foo", bar: "bar")
+        expect(actual).to eq("service2 return")
+      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
+        invoke2!
+        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
+        invoke2!(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
+        invoke2!(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
+        invoke2!(a: "foo", b: "bar", c: "baz", e: "number4", extra3: 3)
+        expect(actual).to eq(%w[foo bar baz number4])
+      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
+        invoke2!
+        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
+        invoke2!(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
+        invoke2!(a: "foo", b: "bar", c: "baz", e: "number4")
+        expect(actual).to eq(%w[foo bar baz number4])
+      end
+    end
+
+    context "with extra named args" do
+      it "ignores extra args" do
+        invoke2!(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
+        invoke2!
+        expect(actual).to be_a(::Simple::Service::MissingArguments)
+      end
+    end
+
+    context "with the required number of args" do
+      it "runs" do
+        invoke2!(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
+        invoke2!(a: "foo", b: "bar", c: "baz", e: "number4")
+        expect(actual).to eq(%w[foo bar baz number4])
+      end
+    end
+
+    context "with extra named args" do
+      it "ignores extra args" do
+        invoke2!(a: "foo", b: "bar", c: "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

@@ -0,0 +1,266 @@
+# 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)
+    # rescue ::StandardError => e
+  rescue ::Simple::Service::ArgumentError => e
+    @actual = e
+  end
+
+  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
+    #
+    # def no_params
+    #   "service2 return"
+    # end
+
+    let(:action) { :no_params }
+
+    context "calling without args" do
+      it "runs the action" do
+        invoke!
+        expect(actual).to eq("service2 return")
+      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")
+        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)
+      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
+        invoke!
+        expect(actual).to be_a(::Simple::Service::MissingArguments)
+      end
+    end
+
+    context "with the required number of args" do
+      it "runs" do
+        invoke!("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
+        invoke!("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
+        invoke!("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
+        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)
+      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
+        invoke!
+        expect(actual).to be_a(::Simple::Service::MissingArguments)
+      end
+    end
+
+    context "with the required number of args" do
+      it "runs" do
+        invoke!(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")
+        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)
+        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
+        invoke!
+        expect(actual).to be_a(::Simple::Service::MissingArguments)
+      end
+    end
+
+    context "with the required number of args" do
+      it "runs" do
+        invoke!("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")
+        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)
+        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
+        invoke!
+        expect(actual).to be_a(::Simple::Service::MissingArguments)
+      end
+    end
+
+    context "with the required number of args" do
+      it "runs" do
+        invoke!("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")
+        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")
+        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"])
+      end
+    end
+  end
+end