zen-service 1.0.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/zen/service.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "service/version"
+require_relative "service/plugins"
+
+module Zen
+  class Service
+    autoload :SpecHelpers, "zen/service/spec_helpers"
+
+    extend Plugins::Pluggable
+
+    use :executable
+    use :attributes
+  end
+end

data/lib/zen/service/plugins.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Zen
+  module Service::Plugins
+    def self.fetch(name)
+      require("zen/service/plugins/#{name}") unless plugins.key?(name)
+
+      plugins[name] || raise("extension `#{name}` is not registered")
+    end
+
+    def self.register(name, extension)
+      raise(ArgumentError, "extension `#{name}` is already registered") if plugins.key?(name)
+
+      plugins[name] =
+        if (old_name = plugins.key(extension))
+          plugins.delete(old_name)
+        else
+          extension
+        end
+    end
+
+    def self.plugins
+      @plugins ||= {}
+    end
+  end
+
+  require_relative "plugins/plugin"
+  require_relative "plugins/pluggable"
+  require_relative "plugins/executable"
+  require_relative "plugins/attributes"
+  require_relative "plugins/assertions"
+  require_relative "plugins/context"
+  require_relative "plugins/execution_cache"
+  require_relative "plugins/policies"
+  require_relative "plugins/rescue"
+  require_relative "plugins/status"
+  require_relative "plugins/validation"
+end

data/lib/zen/service/plugins/assertions.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Zen
+  module Service::Plugins
+    module Assertions
+      extend Plugin
+
+      private def assert
+        if yield
+          success! unless state.has_success?
+        else
+          failure!
+        end
+      end
+    end
+  end
+end

data/lib/zen/service/plugins/attributes.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Zen
+  module Service::Plugins
+    module Attributes
+      extend Plugin
+
+      def initialize(*args)
+        @attributes = assert_valid_attributes!(resolve_args!(args))
+
+        super()
+      end
+
+      def initialize_clone(*)
+        super
+        @attributes = @attributes.dup unless @attributes.nil?
+      end
+
+      def with_attributes(attributes)
+        clone.tap { |copy| copy.attributes.merge!(attributes) }
+      end
+
+      protected def attributes
+        @attributes
+      end
+
+      private def resolve_args!(args) # rubocop:disable Metrics/AbcSize
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        attributes = {}
+        allowed_length = self.class.attributes_list.length
+
+        if args.length > allowed_length
+          raise ArgumentError, "wrong number of attributes (given #{args.length}, expected 0..#{allowed_length})"
+        end
+
+        args.each_with_index do |value, i|
+          attributes[self.class.attributes_list[i]] = value
+        end
+
+        opts.each do |name, value|
+          raise(ArgumentError, "attribute #{name} has already been provided as parameter") if attributes.key?(name)
+
+          attributes[name] = value
+        end
+
+        attributes
+      end
+
+      private def assert_valid_attributes!(actual)
+        unexpected = actual.keys - self.class.attributes_list
+
+        raise(ArgumentError, "wrong attributes #{unexpected} given") if unexpected.any?
+
+        actual
+      end
+
+      module ClassMethods
+        def inherited(service_class)
+          service_class.const_set(:AttributeMethods, Module.new)
+          service_class.send(:include, service_class::AttributeMethods)
+          service_class.attributes_list.replace attributes_list.dup
+          super
+        end
+
+        def attribute_methods
+          const_get(:AttributeMethods)
+        end
+
+        def attributes(*attrs)
+          attributes_list.concat(attrs)
+
+          attrs.each do |name|
+            attribute_methods.send(:define_method, name) { @attributes[name] }
+            attribute_methods.send(:define_method, "#{name}?") { !!@attributes[name] }
+          end
+        end
+
+        def attributes_list
+          @attributes_list ||= []
+        end
+
+        def from(service)
+          new(service.send(:attributes))
+        end
+      end
+    end
+  end
+end

data/lib/zen/service/plugins/context.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Zen
+  module Service::Plugins
+    module Context
+      extend Plugin
+
+      attr_accessor :local_context
+      protected :local_context, :local_context=
+
+      def context
+        global_context = ::Zen::Service.context
+        return global_context if local_context.nil?
+
+        if global_context.respond_to?(:merge)
+          global_context.merge(local_context)
+        else
+          local_context
+        end
+      end
+
+      def with_context(ctx)
+        clone.tap do |copy|
+          copy.local_context =
+            copy.local_context.respond_to?(:merge) ? copy.local_context.merge(ctx) : ctx
+        end
+      end
+
+      def execute(*)
+        ::Zen::Service.with_context(context) do
+          super
+        end
+      end
+
+      module ServiceMethods
+        def with_context(ctx)
+          current = context
+          Thread.current[:zen_service_context] = context.respond_to?(:merge) ? context.merge(ctx) : ctx
+
+          yield
+        ensure
+          Thread.current[:zen_service_context] = current
+        end
+
+        def context
+          Thread.current[:zen_service_context]
+        end
+      end
+
+      service_extension ServiceMethods
+    end
+  end
+end

data/lib/zen/service/plugins/executable.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "ostruct"
+
+module Zen
+  module Service::Plugins
+    module Executable
+      extend Plugin
+
+      class State
+        def self.prop_names
+          @prop_names ||= []
+        end
+
+        def self.add_prop(*props)
+          prop_names.push(*props)
+          props.each { |prop| def_prop_accessor(prop) }
+        end
+
+        def self.def_prop_accessor(name)
+          define_method(name) { @values[name] }
+          define_method("#{name}=") { |value| @values[name] = value }
+          define_method("has_#{name}?") { @values.key?(name) }
+        end
+
+        def initialize(values = {})
+          @values = values
+        end
+
+        def clear!
+          @values.clear
+        end
+
+        def prop_names
+          self.class.prop_names
+        end
+
+        def replace(other)
+          missing_props = prop_names - other.prop_names
+
+          unless missing_props.empty?
+            raise ArgumentError, "cannot accept execution state #{other} due to missing props: #{missing_props}"
+          end
+
+          prop_names.each do |prop|
+            @values[prop] = other.public_send(prop)
+          end
+        end
+      end
+
+      def self.used(service_class, *)
+        service_class.const_set(:State, Class.new(State))
+        service_class.add_execution_prop(:executed, :success, :result)
+      end
+
+      attr_reader :state
+
+      def initialize(*)
+        @state = self.class::State.new(executed: false)
+      end
+
+      def initialize_clone(*)
+        clear_execution_state!
+      end
+
+      def execute(*, &block)
+        clear_execution_state!
+        result = execute!(&block)
+        result_with(result) unless state.has_result?
+        state.executed = true
+
+        self
+      end
+
+      def executed?
+        state.executed
+      end
+
+      def ~@
+        state
+      end
+
+      private def execute!
+        success!
+      end
+
+      private def clear_execution_state!
+        state.clear!
+        state.executed = false
+      end
+
+      private def success(**)
+        assign_successful_state
+        assign_successful_result(yield)
+      end
+
+      private def failure(**)
+        assign_failed_state
+        assign_failed_result(yield)
+      end
+
+      private def success!(**)
+        assign_successful_state
+      end
+
+      private def failure!(**)
+        assign_failed_state
+      end
+
+      private def assign_successful_state
+        state.success = true
+        state.result = nil
+      end
+
+      private def assign_failed_state
+        state.success = false
+        state.result = nil
+      end
+
+      private def assign_successful_result(value)
+        state.result = value
+      end
+
+      private def assign_failed_result(value)
+        state.result = value
+      end
+
+      def result
+        return state.result unless block_given?
+
+        result_with(yield)
+      end
+
+      private def result_with(obj)
+        return state.replace(obj) if obj.is_a?(State)
+
+        state.success = !!obj
+        if state.success
+          assign_successful_result(obj)
+        else
+          assign_failed_result(obj)
+        end
+      end
+
+      def success?
+        state.success == true
+      end
+
+      def failure?
+        !success?
+      end
+
+      module ClassMethods
+        def inherited(klass)
+          klass.const_set(:State, Class.new(self::State))
+          klass::State.prop_names.replace(self::State.prop_names.dup)
+        end
+
+        def add_execution_prop(*props)
+          self::State.add_prop(*props)
+        end
+
+        def call(*args)
+          new(*args).execute
+        end
+        alias execute call
+
+        def [](*args)
+          call(*args).result
+        end
+
+        def method_added(name)
+          private :execute! if name == :execute!
+          super if defined? super
+        end
+      end
+    end
+  end
+end

data/lib/zen/service/plugins/execution_cache.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Zen
+  module Service::Plugins
+    module ExecutionCache
+      extend Plugin
+
+      def initialize(*)
+        super
+        extend Extension
+      end
+
+      module Extension
+        def execute(*)
+          return super if block_given? || !executed?
+
+          self
+        end
+      end
+    end
+  end
+end

data/lib/zen/service/plugins/pluggable.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Zen
+  module Service::Plugins
+    module Pluggable
+      def use(name, **opts)
+        extension = Service::Plugins.fetch(name)
+
+        defaults = extension.config[:default_options]
+        opts = defaults.merge(opts) unless defaults.nil?
+
+        if using?(name)
+          extension.configure(self, **opts) if extension.respond_to?(:configure)
+          return extension
+        end
+
+        use_extension(extension, name, **opts)
+      end
+
+      private def use_extension(extension, name, **opts)
+        include extension
+        extend extension::ClassMethods if extension.const_defined?(:ClassMethods)
+
+        extension.used(self, **opts) if extension.respond_to?(:used)
+        extension.configure(self, **opts) if extension.respond_to?(:configure)
+
+        plugins[name] = Reflection.new(extension, opts)
+
+        extension
+      end
+
+      def using?(name)
+        plugins.key?(name)
+      end
+
+      def plugins
+        @plugins ||= {}
+      end
+      alias extensions plugins
+
+      Reflection = Struct.new(:extension, :options)
+    end
+  end
+end