simple-service 0.1.3

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

@@ -0,0 +1,29 @@
+module Simple # :nodoc:
+end
+
+module Simple::Service
+  module GemHelper # :nodoc:
+    extend self
+
+    def version(name)
+      spec = Gem.loaded_specs[name]
+      version = spec ? spec.version.to_s : "0.0.0"
+      version += "+unreleased" if !spec || unreleased?(spec)
+      version
+    end
+
+    private
+
+    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
+
+  VERSION = GemHelper.version "simple-service"
+end

data/scripts/release

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

data/scripts/release.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+# -- helpers ------------------------------------------------------------------
+
+def sys(cmd)
+  STDERR.puts "> #{cmd}"
+  system cmd
+  return true if $?.success?
+
+  STDERR.puts "> #{cmd} returned with exitstatus #{$?.exitstatus}"
+  $?.success?
+end
+
+def sys!(cmd, error: nil)
+  return true if sys(cmd)
+  STDERR.puts error if error
+  exit 1
+end
+
+def die!(msg)
+  STDERR.puts msg
+  exit 1
+end
+
+ROOT = File.expand_path("#{File.dirname(__FILE__)}/..")
+
+GEMSPEC = Dir.glob("*.gemspec").first || die!("Missing gemspec file.")
+
+# -- Version reading and bumping ----------------------------------------------
+
+module Version
+  extend self
+
+  VERSION_FILE = "#{Dir.getwd}/VERSION"
+
+  def read_version
+    version = File.exist?(VERSION_FILE) ? File.read(VERSION_FILE) : "0.0.1"
+    version.chomp!
+    raise "Invalid version number in #{VERSION_FILE}" unless version =~ /^\d+\.\d+\.\d+$/
+    version
+  end
+
+  def auto_version_bump
+    old_version_number = read_version
+    old = old_version_number.split('.')
+
+    current = old[0..-2] << old[-1].next
+    current.join('.')
+  end
+
+  def bump_version
+    next_version = ENV["VERSION"] || auto_version_bump
+    File.open(VERSION_FILE, "w") { |io| io.write next_version }
+  end
+end
+
+# -- check, bump, release a new gem version -----------------------------------
+
+Dir.chdir ROOT
+$BASE_BRANCH = ENV['BRANCH'] || 'master'
+
+# ENV["BUNDLE_GEMFILE"] = "#{Dir.getwd}/Gemfile"
+# sys! "bundle install"
+
+sys! "git diff --exit-code > /dev/null", error: 'There are unstaged changes in your working directory'
+sys! "git diff --cached --exit-code > /dev/null", error: 'There are staged but uncommitted changes'
+
+sys! "git checkout #{$BASE_BRANCH}"
+sys! "git pull"
+
+Version.bump_version
+version = Version.read_version
+
+sys! "git add VERSION"
+sys! "git commit -m \"bump gem to v#{version}\""
+sys! "git tag -a v#{version} -m \"Tag #{version}\""
+
+sys! "gem build #{GEMSPEC}"
+
+sys! "git push origin #{$BASE_BRANCH}"
+sys! 'git push --tags --force'
+sys! "gem push #{Dir.glob('*.gem').first}"
+
+sys! "mkdir -p pkg"
+sys! "mv *.gem pkg"
+
+STDERR.puts <<-MSG
+================================================================================
+Thank you for releasing a new gem version. You made my day.
+================================================================================
+    MSG

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