simple-service 0.1.4

data/scripts/stats

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+# 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/scripts/watch

@@ -0,0 +1,2 @@
+#!/bin/bash
+watchr lib,spec rspec $@

data/simple-service.gemspec

@@ -0,0 +1,25 @@
+# lib = File.expand_path('../lib', __FILE__)
+# $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |gem|
+  gem.name     = "simple-service"
+  gem.version  = File.read("VERSION")
+
+  gem.authors  = [ "radiospiel" ]
+  gem.email    = "eno@radiospiel.org"
+  gem.homepage = "http://github.com/radiospiel/simple-service"
+  gem.summary  = "Pretty simple and somewhat abstract service description"
+
+  gem.description = "Pretty simple and somewhat abstract service description"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths =  %w(lib)
+
+  # executables are used for development purposes only
+  gem.executables   = []
+
+  gem.required_ruby_version = '~> 2.5'
+
+  gem.add_dependency "expectation", "~> 1"
+end

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