simple-service 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9641586855a538c0b450d4731d39d28f23c4ee19abec379f5ac9047888fe9106
+  data.tar.gz: a395f0a7815935557163cc81532ef7e3fc2b97dfc2bf7347e32460481589dd1d
+SHA512:
+  metadata.gz: 43a8d60d9c7b1f14913f431b24ebd50db6a41c2b951a41bd8b1c136d466b2d198b0582e7adcbc34b0df0c81206abe79fda05ea25f8e9c74c4f52a5722e23146a
+  data.tar.gz: a0376b41661076f53a4ffe6a20650efc6dda513f762ddd0e96d7c7da0f568b6dc2e687c4fbfb67da759f7ac076ce115468a0fd2ba63a686f7ab15504a1ee5cd8

data/.gitignore

@@ -0,0 +1,12 @@
+coverage
+rdoc
+pkg
+log/*.log
+.rspec.data
+Gemfile.lock
+.rake_t_cache
+.rspec.status
+.DS_Store
+tmp
+.byebug_history
+.bundle/config

data/.rubocop.yml

@@ -0,0 +1,96 @@
+AllCops:
+  TargetRubyVersion: 2.3
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'bin/**/*'
+    - 'tasks/release.rake'
+    - '*.gemspec'
+    - 'Gemfile'
+    - 'Rakefile'
+    - 'scripts/*.rb'
+
+Metrics/LineLength:
+  Max: 140
+
+Metrics/MethodLength:
+  Max: 20
+
+Style/SpecialGlobalVars:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+  ConsistentQuotesInMultiline: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/ModuleFunction:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/MutableConstant:
+  Enabled: false
+
+Style/FormatStringToken:
+  Enabled: false
+
+Style/Lambda:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: false
+
+Style/FormatString:
+  Enabled: false
+
+Style/PercentLiteralDelimiters:
+  Enabled: false
+
+Lint/MissingCopEnableDirective:
+  Enabled: false
+
+Style/NumericPredicate:
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/ClassVars:
+  Enabled: false
+
+Style/ConditionalAssignment:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/PerlBackrefs:
+  Enabled: false
+
+Style/TrailingUnderscoreVariable:
+  Enabled: false
+  
+Style/StderrPuts:
+  Enabled: false
+
+Style/NonNilCheck:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Style/StringLiteralsInInterpolation:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/ParallelAssignment:
+  Enabled: false

data/.tm_properties

@@ -0,0 +1 @@
+excludeDirectories = "{_build,coverage,assets/node_modules,node_modules,deps,db,cover,priv/static,storage,github,vendor,arena,}"

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in {gemname}.gemspec
+gemspec
+
+# --- Development and test dependencies ------------------------------
+
+group :development, :test do
+  gem 'rake', '~> 11'
+  gem 'rspec', '~> 3.7'
+  # gem 'rubocop', '~> 0.61.1'
+  gem 'simplecov', '~> 0'
+  gem 'byebug'
+end

data/Makefile

@@ -0,0 +1,4 @@
+.PHONY: test
+
+test:
+	rspec

data/README.md

@@ -0,0 +1 @@
+# simple-service – a pretty simple and somewhat abstract service description

data/Rakefile

@@ -0,0 +1,6 @@
+Dir.glob("tasks/*.rake").each { |r| import r }
+
+task :release do
+  sh "scripts/release"
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/bin/bundle

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'bundle' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "rubygems"
+
+m = Module.new do
+    module_function
+
+  def invoked_as_script?
+    File.expand_path($0) == File.expand_path(__FILE__)
+  end
+
+  def env_var_version
+    ENV["BUNDLER_VERSION"]
+  end
+
+  def cli_arg_version
+    return unless invoked_as_script? # don't want to hijack other binstubs
+    return unless "update".start_with?(ARGV.first || " ") # must be running `bundle update`
+    bundler_version = nil
+    update_index = nil
+    ARGV.each_with_index do |a, i|
+      if update_index && update_index.succ == i && a =~ Gem::Version::ANCHORED_VERSION_PATTERN
+        bundler_version = a
+      end
+      next unless a =~ /\A--bundler(?:[= ](#{Gem::Version::VERSION_PATTERN}))?\z/
+      bundler_version = $1 || ">= 0.a"
+      update_index = i
+    end
+    bundler_version
+  end
+
+  def gemfile
+    gemfile = ENV["BUNDLE_GEMFILE"]
+    return gemfile if gemfile && !gemfile.empty?
+
+    File.expand_path("../../Gemfile", __FILE__)
+  end
+
+  def lockfile
+    lockfile =
+      case File.basename(gemfile)
+      when "gems.rb" then gemfile.sub(/\.rb$/, gemfile)
+      else "#{gemfile}.lock"
+      end
+    File.expand_path(lockfile)
+  end
+
+  def lockfile_version
+    return unless File.file?(lockfile)
+    lockfile_contents = File.read(lockfile)
+    return unless lockfile_contents =~ /\n\nBUNDLED WITH\n\s{2,}(#{Gem::Version::VERSION_PATTERN})\n/
+    Regexp.last_match(1)
+  end
+
+  def bundler_version
+    @bundler_version ||= begin
+      env_var_version || cli_arg_version ||
+        lockfile_version || "#{Gem::Requirement.default}.a"
+    end
+  end
+
+  def load_bundler!
+    ENV["BUNDLE_GEMFILE"] ||= gemfile
+
+    # must dup string for RG < 1.8 compatibility
+    activate_bundler(bundler_version.dup)
+  end
+
+  def activate_bundler(bundler_version)
+    if Gem::Version.correct?(bundler_version) && Gem::Version.new(bundler_version).release < Gem::Version.new("2.0")
+      bundler_version = "< 2"
+    end
+    gem_error = activation_error_handling do
+      gem "bundler", bundler_version
+    end
+    return if gem_error.nil?
+    require_error = activation_error_handling do
+      require "bundler/version"
+    end
+    return if require_error.nil? && Gem::Requirement.new(bundler_version).satisfied_by?(Gem::Version.new(Bundler::VERSION))
+    warn "Activating bundler (#{bundler_version}) failed:\n#{gem_error.message}\n\nTo install the version of bundler this project requires, run `gem install bundler -v '#{bundler_version}'`"
+    exit 42
+  end
+
+  def activation_error_handling
+    yield
+    nil
+  rescue StandardError, LoadError => e
+    e
+  end
+end
+
+m.load_bundler!
+
+if m.invoked_as_script?
+  load Gem.bin_path("bundler", "bundle")
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+Bundler.require
+require "simple-service"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/rake

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/rspec

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

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

@@ -0,0 +1,57 @@
+# returns the comment for an action
+class ::Simple::Service::Action::Comment
+  attr_reader :short
+  attr_reader :full
+
+  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
+    new short: lines[0], full: full
+  end
+
+  def initialize(short:, full:)
+    @short, @full = short, full
+  end
+
+  module Extractor
+    extend self
+
+    # reads the source \a file and turns each non-comment into :code and each comment
+    # into a string without the leading comment markup.
+    def parse_source(file)
+      @parsed_sources ||= {}
+      @parsed_sources[file] = _parse_source(file)
+    end
+
+    def _parse_source(file)
+      File.readlines(file).map do |line|
+        case line
+        when /^\s*# ?(.*)$/ then $1
+        when /^\s*end/ then :end
+        end
+      end
+    end
+
+    def extract_comment_lines(file:, before_line:)
+      parsed_source = parse_source(file)
+
+      # go down from before_line until we see a line which is either a comment
+      # or an :end. Note that the line at before_line-1 should be the first
+      # line of the method definition in question.
+      last_line = before_line - 1
+      last_line -= 1 while last_line >= 0 && !parsed_source[last_line]
+
+      first_line = last_line
+      first_line -= 1 while first_line >= 0 && parsed_source[first_line]
+      first_line += 1
+
+      comments = parsed_source[first_line..last_line]
+      if comments.include?(:end)
+        []
+      else
+        parsed_source[first_line..last_line]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# rubocop:disable Metrics/AbcSize
+
+module ::Simple::Service::Action::MethodReflection # :nodoc:
+  extend self
+
+  #
+  # returns an array with entries like the following:
+  #
+  #  [ :key, name, default_value ]
+  #  [ :keyreq, name [, nil ] ]
+  #  [ :req, name [, nil ] ]
+  #  [ :opt, name [, nil ] ]
+  #  [ :rest, name [, nil ] ]
+  #
+  def parameters(service, method_id)
+    method = service.instance_method(method_id)
+    parameters = method.parameters
+
+    # method parameters with a :key mode are optional keyword 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?
+
+    # We are now doing a fake call to the method, with a minimal viable set of
+    # arguments, to let the ruby runtime fill in default values for arguments.
+    # We do not, however, let the call complete. Instead we use a TracePoint to
+    # abort as soon as the method is called, and use the its binding to determine
+    # the default values.
+
+    fake_recipient = Object.new.extend(service)
+    fake_call_args = minimal_arguments(method)
+
+    trace_point = TracePoint.trace(:call) do |tp|
+      throw :received_fake_call, tp.binding if tp.defined_class == service && tp.method_id == method_id
+    end
+
+    bnd = catch(:received_fake_call) do
+      fake_recipient.send(method_id, *fake_call_args)
+    end
+
+    trace_point.disable
+
+    # extract default values from the received binding, and merge with the
+    # parameters array.
+    default_values = keys.each_with_object({}) do |key_parameter, hsh|
+      hsh[key_parameter] = bnd.local_variable_get(key_parameter)
+    end
+
+    parameters.map do |mode, name|
+      [mode, name, default_values[name]]
+    end
+  end
+
+  private
+
+  # returns a minimal Array of arguments, which is suitable for a call to the method
+  def minimal_arguments(method)
+    # Build an arguments array with holds all required parameters. The actual
+    # 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
+    required_keyword_args = method.parameters.each_with_object({}) do |(mode, name), hsh|
+      hsh[name] = :anything if mode == :keyreq
+    end
+    args << required_keyword_args if required_keyword_args
+
+    args
+  end
+end

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

@@ -0,0 +1,46 @@
+require_relative "method_reflection"
+
+class ::Simple::Service::Action::Parameter
+  def self.reflect_on_method(service:, name:)
+    reflected_parameters = ::Simple::Service::Action::MethodReflection.parameters(service, name)
+    @parameters = reflected_parameters.map { |ary| new(*ary) }
+  end
+
+  def keyword?
+    [:key, :keyreq].include? @kind
+  end
+
+  def anonymous?
+    [:req, :opt].include? @kind
+  end
+
+  def required?
+    [:req, :keyreq].include? @kind
+  end
+
+  def variadic?
+    @kind == :rest
+  end
+
+  def optional?
+    !required?
+  end
+
+  attr_reader :name
+  attr_reader :kind
+
+  # The parameter's default value (if any)
+  attr_reader :default_value
+
+  def initialize(kind, name, *default_value)
+    # The parameter list matches the values returned from MethodReflection.parameters,
+    # which has two or three entries: <tt>kind, name [ . default_value ]</tt>
+
+    expect! kind => [:req, :opt, :keyreq, :key, :rest]
+    expect! default_value.length => [0, 1]
+
+    @kind = kind
+    @name = name
+    @default_value = default_value[0]
+  end
+end

data/lib/simple/service/action.rb

@@ -0,0 +1,193 @@
+# rubocop:disable Metrics/CyclomaticComplexity
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/PerceivedComplexity
+
+module Simple::Service
+  class Action
+  end
+end
+
+require_relative "./action/comment"
+require_relative "./action/parameter"
+
+module Simple::Service
+  class Action
+    ArgumentError = ::Simple::Service::ArgumentError
+
+    IDENTIFIER_PATTERN = "[a-z][a-z0-9_]*"
+    IDENTIFIER_REGEXP = Regexp.compile("\\A#{IDENTIFIER_PATTERN}\\z")
+
+    # determines all services provided by the +service+ service module.
+    def self.enumerate(service:) # :nodoc:
+      service.public_instance_methods(false)
+             .grep(IDENTIFIER_REGEXP)
+             .each_with_object({}) { |name, hsh| hsh[name] = Action.new(service, name) }
+    end
+
+    attr_reader :service
+    attr_reader :name
+
+    # returns an Array of Parameter structures.
+    def parameters
+      @parameters ||= Parameter.reflect_on_method(service: service, name: name)
+    end
+
+    def initialize(service, name)
+      @service  = service
+      @name     = name
+
+      parameters
+    end
+
+    def short_description
+      comment.short
+    end
+
+    def full_description
+      comment.full
+    end
+
+    private
+
+    # returns a Comment object
+    #
+    # The comment object is extracted on demand on the first call.
+    def comment
+      @comment ||= Comment.extract(action: self)
+    end
+
+    public
+
+    def source_location
+      @service.instance_method(name).source_location
+    end
+
+    # build a service_instance and run the action, with arguments constructed from
+    # args_hsh and params_hsh.
+    def invoke(args, options)
+      args   ||= {}
+      options ||= {}
+
+      # convert Array arguments into a Hash of named arguments. This is strictly
+      # necessary to be able to apply default value-based type conversions. (On
+      # the downside this also means we convert an array to a hash and then back
+      # into an array. This, however, should only be an issue for CLI based action
+      # invocations, because any other use case (that I can think of) should allow
+      # us to provide arguments as a Hash. 
+      if args.is_a?(Array)
+        args = convert_argument_array_to_hash(args)
+      end
+
+      # [TODO] Type conversion according to default values.
+      args_ary = build_method_arguments(args, options)
+
+      service_instance = Object.new
+      service_instance.extend service
+      service_instance.public_send(@name, *args_ary)
+    end
+
+    private
+
+    module IndifferentHashEx
+      def self.fetch(hsh, name)
+        missing_key!(name) unless hsh
+
+        hsh.fetch(name.to_sym) do
+          hsh.fetch(name.to_s) do
+            missing_key!(name)
+          end
+        end
+      end
+
+      def self.key?(hsh, name)
+        return false unless hsh
+
+        hsh.key?(name.to_sym) || hsh.key?(name.to_s)
+      end
+
+      def self.missing_key!(name)
+        raise ArgumentError, "Missing argument in arguments hash: #{name}"
+      end
+    end
+
+    I = IndifferentHashEx
+
+    # returns an array of arguments suitable to be sent to the action method.
+    def build_method_arguments(args_hsh, params_hsh)
+      args = []
+      keyword_args = {}
+
+      parameters.each do |parameter|
+        if parameter.keyword?
+          if I.key?(params_hsh, parameter.name)
+            keyword_args[parameter.name] = I.fetch(params_hsh, parameter.name)
+          end
+        else
+          if parameter.variadic?
+            if I.key?(args_hsh, parameter.name)
+              args.concat(Array(I.fetch(args_hsh, parameter.name)))
+            end
+          else
+            if !parameter.optional? || I.key?(args_hsh, parameter.name)
+              args << I.fetch(args_hsh, parameter.name)
+            end
+          end
+        end
+      end
+
+      unless keyword_args.empty?
+        args << keyword_args
+      end
+
+      args
+    end
+
+    def convert_argument_array_to_hash(ary)
+      # enumerate all of the action's anonymous arguments, trying to match them
+      # against the values in +ary+. If afterwards any arguments are still left
+      # in +ary+ they will be assigned to the variadic arguments array, which
+      # - if a variadic parameter is defined in this action - will be added to
+      # the hash as well.
+      hsh = {}
+      variadic_parameter_name = nil
+
+      parameters.each do |parameter|
+        next if parameter.keyword?
+        parameter_name = parameter.name
+
+        if parameter.variadic?
+          variadic_parameter_name = parameter_name
+          next
+        end
+
+        if ary.empty? && !parameter.optional?
+          raise ::Simple::Service::ArgumentError, "Missing #{parameter_name} parameter"
+        end
+
+        next if ary.empty?
+
+        hsh[parameter_name] = ary.shift
+      end
+
+      # Any arguments are left? Set variadic parameter, if defined, raise an error otherwise.
+      unless ary.empty?
+        unless variadic_parameter_name
+          raise ::Simple::Service::ArgumentError, "Extra parameters: #{ary.map(&:inspect).join(", ")}"
+        end
+
+        hsh[variadic_parameter_name] = ary
+      end
+
+      hsh
+    end
+
+    def full_name
+      "#{service}##{name}"
+    end
+
+    def to_s
+      full_name
+    end
+  end
+end

data/lib/simple/service/context.rb

@@ -0,0 +1,52 @@
+module Simple::Service
+  class Context
+    class ReadOnlyError < RuntimeError
+      def initialize(key)
+        super "Cannot overwrite existing context setting #{key.inspect}"
+      end
+    end
+
+    def initialize
+      @hsh = {}
+    end
+
+    private
+
+    def [](key)
+      @hsh[key]
+    end
+
+    def []=(key, value)
+      existing_value = @hsh[key]
+
+      unless existing_value.nil? || existing_value == value
+        raise ReadOnlyError, key
+      end
+
+      @hsh[key] = value
+    end
+
+    IDENTIFIER_PATTERN = "[a-z][a-z0-9_]*"
+    IDENTIFIER_REGEXP = Regexp.compile("\\A#{IDENTIFIER_PATTERN}\\z")
+    ASSIGNMENT_REGEXP = Regexp.compile("\\A(#{IDENTIFIER_PATTERN})=\\z")
+
+    def method_missing(sym, *args, &block)
+      if block
+        super
+      elsif 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)
+      return true if IDENTIFIER_REGEXP.maptch?(sym)
+      return true if ASSIGNMENT_REGEXP.maptch?(sym)
+
+      super
+    end
+  end
+end

data/lib/simple/service/version.rb

@@ -0,0 +1,24 @@
+class Simple::Service
+  module GemHelper
+    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)
+      return true if spec.source.is_a?(::Bundler::Source::Path)
+
+      false
+    end
+  end
+
+  VERSION = GemHelper.version "simple-service"
+end

data/lib/simple/service.rb

@@ -0,0 +1,89 @@
+module Simple::Service
+  class ArgumentError < ::ArgumentError
+  end
+end
+
+require_relative "service/action"
+require_relative "service/context"
+
+# The Simple::Service module.
+#
+# To mark a target module as a service module one must include the
+# Simple::Service module into the target module.
+#
+# This serves as a marker that this module is actually intended
+# to be used as a service.
+module Simple::Service
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+
+  # 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, &block)
+    expect! ctx => [Simple::Service::Context, nil]
+    _ = block
+
+    old_ctx = Thread.current[:"Simple::Service.context"]
+    Thread.current[:"Simple::Service.context"] = ctx
+    yield
+  ensure
+    Thread.current[:"Simple::Service.context"] = old_ctx
+  end
+
+  def self.action(service, name)
+    actions = self.actions(service)
+    actions[name] || begin
+      action_names = actions.keys.sort
+      informal = "service #{service} has these actions: #{action_names.map(&:inspect).join(", ")}"
+      raise "No such action #{name.inspect}; #{informal}"
+    end
+  end
+
+  def self.service?(service)
+    service.is_a?(Module) && service.include?(self)
+  end
+
+  def self.actions(service)
+    raise ArgumentError, "service must be a #{self}" unless service?(service)
+
+    service.__simple_service_actions__
+  end
+
+  def self.invoke(service, name, arguments, params, context: nil)
+    with_context(context) do
+      action(service, name).invoke(arguments, params)
+    end
+  end
+
+  module ClassMethods
+    # returns a Hash of actions provided by the service module.
+    def __simple_service_actions__ # :nodoc:
+      @__simple_service_actions__ ||= Action.enumerate(service: self)
+    end
+  end
+
+  # Resolves a service by name. Returns nil if the name does not refer to a service,
+  # or the service module otherwise.
+  def self.resolve(str)
+    return unless str =~ /^[A-Z][A-Za-z0-9_]*(::[A-Z][A-Za-z0-9_]*)*$/
+
+    service = resolve_constant(str)
+
+    return unless service.is_a?(Module)
+    return unless service.include?(::Simple::Service)
+
+    service
+  end
+
+  def self.resolve_constant(str)
+    const_get(str)
+  rescue NameError
+    nil
+  end
+end

data/lib/simple-service.rb

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

data/lib/simple.rb

@@ -0,0 +1,2 @@
+module Simple
+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,4 @@
+#!/bin/bash
+
+cloc $(find lib/ -name *rb) | grep -E 'Language|Ruby' | sed 's-Language-        -'
+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/context_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe Simple::Service::Context do
+  let(:context) { Simple::Service::Context.new }
+  
+  before do
+    context.one = 1
+  end
+
+  describe "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 "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::Context::ReadOnlyError)
+    end
+
+    it "sets the value if it exists and is equal" do
+      context.one = 1
+      expect(context.one).to eq(1)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+ENV["RACK_ENV"] = "test"
+ENV["RAILS_ENV"] = "test"
+
+require "byebug"
+require "rspec"
+
+Dir.glob("./spec/support/**/*.rb").sort.each { |path| load path }
+
+require "simple/service"
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run focus: (ENV["CI"] != "true")
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+  config.order = "random"
+  config.example_status_persistence_file_path = ".rspec.data"
+
+  config.backtrace_exclusion_patterns << /spec\/support/
+  config.backtrace_exclusion_patterns << /spec_helper/
+  config.backtrace_exclusion_patterns << /database_cleaner/
+
+  # config.around(:each) do |example|
+  #   example.run
+  # end
+end

data/spec/support/004_simplecov.rb

@@ -0,0 +1,13 @@
+require "simplecov"
+
+SimpleCov.start do
+  # return true to remove src from coverage
+  add_filter do |src|
+    next true if src.filename =~ /\/spec\//
+    next true if src.filename =~ /\/version.rb$/
+
+    false
+  end
+
+  # minimum_coverage 90
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: simple-service
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- radiospiel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: expectation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: Pretty simple and somewhat abstract service description
+email: eno@radiospiel.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".tm_properties"
+- Gemfile
+- Makefile
+- README.md
+- Rakefile
+- VERSION
+- bin/bundle
+- bin/console
+- bin/rake
+- bin/rspec
+- lib/simple-service.rb
+- lib/simple.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/version.rb
+- log/.gitkeep
+- scripts/release
+- scripts/release.rb
+- scripts/stats
+- scripts/watch
+- simple-service.gemspec
+- spec/simple/service/context_spec.rb
+- spec/spec_helper.rb
+- spec/support/004_simplecov.rb
+homepage: http://github.com/radiospiel/simple-service
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Pretty simple and somewhat abstract service description
+test_files:
+- spec/simple/service/context_spec.rb
+- spec/spec_helper.rb
+- spec/support/004_simplecov.rb