simple-service 0.1.4

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

@@ -0,0 +1,57 @@
+# returns the comment for an action
+class ::Simple::Service::Action::Comment # @private
+  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/indie_hash.rb

@@ -0,0 +1,37 @@
+class Simple::Service::Action
+  # The IndieHash class defines as much of the Hash interface as necessary for simple-service
+  # to successfully run.
+  class IndieHash
+    def initialize(hsh)
+      @hsh = hsh.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
+    end
+
+    def keys
+      @hsh.keys
+    end
+
+    def fetch_values(*keys)
+      keys = keys.map(&:to_s)
+      @hsh.fetch_values(*keys)
+    end
+
+    def key?(sym)
+      @hsh.key?(sym.to_s)
+    end
+
+    def [](sym)
+      @hsh[sym.to_s]
+    end
+
+    def merge(other_hsh)
+      @hsh = @hsh.merge(other_hsh.send(:__hsh__))
+      self
+    end
+
+    private
+
+    def __hsh__
+      @hsh
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# rubocop:disable Metrics/AbcSize
+
+module ::Simple::Service::Action::MethodReflection # @private
+  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 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?
+
+    # 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 named 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,42 @@
+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?
+    [:keyreq, :key].include? @kind
+  end
+
+  def positional?
+    [:req, :opt].include? @kind
+  end
+
+  def required?
+    [:req, :keyreq].include? @kind
+  end
+
+  def variadic?
+    @kind == :rest
+  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/context.rb

@@ -0,0 +1,94 @@
+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/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 # @private
+end
+
+module Simple::Service
+  module GemHelper # @private
+    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