functional-light-service 0.2.4

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+require "rubygems"
+require "bundler/setup"
+
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
+
+task(:default).clear
+task :default => %i[spec rubocop]

data/VERSION

@@ -0,0 +1 @@
+0.2.4

data/functional-light-service.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/functional-light-service/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Boscolo Michele"]
+  gem.email         = ["miboscol@gmail.com"]
+  gem.description   = %q{A service skeleton with an emphasis on simplicity with a pinch a functional programming}
+  gem.summary       = %q{A service skeleton with an emphasis on simplicity with a pinch a functional programming}
+  gem.homepage      = "https://github.com/sphynx79/functional-light-service"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "functional-light-service"
+  gem.require_paths = ["lib"]
+  gem.version       = FunctionalLightService::VERSION
+
+  # gem.add_dependency("activesupport", ">= 5.2.2")
+  
+  gem.add_development_dependency("activesupport", "~> 5.2.0")
+  gem.add_development_dependency("rspec", "~> 3.0")
+  gem.add_development_dependency("simplecov", "~> 0.16.1")
+  gem.add_development_dependency("rubocop", "~> 0.63.1")
+  gem.add_development_dependency("pry", "~> 0.12.2")
+end

data/gemfiles/activesupport_5.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activesupport", "~> 5.0"
+gem "appraisal", "~> 2.0"
+
+gemspec :path => "../"

data/gemfiles/activesupport_5.gemfile.lock

@@ -0,0 +1,82 @@
+PATH
+  remote: ../
+  specs:
+    light-service (0.6.1)
+      activesupport (>= 3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.0.0.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    appraisal (2.1.0)
+      bundler
+      rake
+      thor (>= 0.14.0)
+    ast (2.3.0)
+    coderay (1.1.1)
+    concurrent-ruby (1.0.2)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    i18n (0.7.0)
+    json (2.0.2)
+    method_source (0.8.2)
+    minitest (5.9.0)
+    parser (2.3.1.2)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rainbow (2.1.0)
+    rake (11.2.2)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.2)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    rubocop (0.42.0)
+      parser (>= 2.3.1.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.8.1)
+    simplecov (0.12.0)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    slop (3.6.0)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.1.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 5.0)
+  appraisal (~> 2.0)
+  light-service!
+  pry (~> 0.10)
+  rspec (~> 3.0)
+  rubocop (~> 0.36)
+  simplecov (~> 0.11)
+
+BUNDLED WITH
+   1.12.5

data/lib/functional-light-service/action.rb

@@ -0,0 +1,102 @@
+require 'active_support/deprecation'
+
+module FunctionalLightService
+  module Action
+    def self.extended(base_class)
+      base_class.extend Macros
+      base_class.extend FunctionalLightService::Prelude::Result
+    end
+
+    def self.included(base_class)
+      msg = "including FunctionalLightService::Action is deprecated. " \
+            "Please use `extend FunctionalLightService::Action` instead"
+      ActiveSupport::Deprecation.warn(msg)
+      base_class.extend Macros
+    end
+
+    module Macros
+      def expects(*args)
+        expected_keys.concat(args)
+      end
+
+      def promises(*args)
+        promised_keys.concat(args)
+      end
+
+      def expected_keys
+        @expected_keys ||= []
+      end
+
+      def promised_keys
+        @promised_keys ||= []
+      end
+
+      def ctx(*args)
+        @ctx ||= args
+      end
+
+      def executed
+        define_singleton_method :execute do |context = {}|
+          action_context = create_action_context(context)
+          return action_context if action_context.stop_processing?
+
+          @ctx = action_context
+
+          # Store the action within the context
+          action_context.current_action = self
+
+          Context::KeyVerifier.verify_keys(action_context, self) do
+            action_context.define_accessor_methods_for_keys(all_keys)
+
+            catch(:jump_when_failed) do
+              call_before_action(action_context)
+              yield(action_context)
+              call_after_action(action_context)
+            end
+          end
+        end
+      end
+
+      def rolled_back
+        msg = "`rolled_back` macro can not be invoked again"
+        raise msg if respond_to?(:rollback)
+
+        define_singleton_method :rollback do |context = {}|
+          yield(context)
+
+          context
+        end
+      end
+
+      private
+
+      def create_action_context(context)
+        return context if context.is_a? FunctionalLightService::Context
+
+        FunctionalLightService::Context.make(context)
+      end
+
+      def all_keys
+        expected_keys + promised_keys
+      end
+
+      def call_before_action(context)
+        invoke_callbacks(context[:_before_actions], context)
+      end
+
+      def call_after_action(context)
+        invoke_callbacks(context[:_after_actions], context)
+      end
+
+      def invoke_callbacks(callbacks, context)
+        return context unless callbacks
+
+        callbacks.each do |cb|
+          cb.call(context)
+        end
+
+        context
+      end
+    end
+  end
+end

data/lib/functional-light-service/configuration.rb

@@ -0,0 +1,24 @@
+module FunctionalLightService
+  class Configuration
+    class << self
+      attr_writer :logger, :localization_adapter
+
+      def logger
+        @logger = _default_logger unless instance_variable_defined?("@logger")
+        @logger
+      end
+
+      def localization_adapter
+        @localization_adapter ||= LocalizationAdapter.new
+      end
+
+      private
+
+      def _default_logger
+        logger = Logger.new("/dev/null")
+        logger.level = Logger::WARN
+        logger
+      end
+    end
+  end
+end

data/lib/functional-light-service/context/key_verifier.rb

@@ -0,0 +1,118 @@
+module FunctionalLightService
+  class Context
+    class KeyVerifier
+      attr_reader :context, :action
+
+      def initialize(context, action)
+        @context = context
+        @action = action
+      end
+
+      def are_all_keys_in_context?(keys)
+        not_found_keys = keys_not_found(keys)
+        not_found_keys.none?
+      end
+
+      def keys_not_found(keys)
+        keys ||= context.keys
+        keys - context.keys
+      end
+
+      def format_keys(keys)
+        keys.map { |k| ":#{k}" }.join(', ')
+      end
+
+      def error_message
+        "#{type_name} #{format_keys(keys_not_found(keys))} " \
+        "to be in the context during #{action}"
+      end
+
+      def throw_error_predicate(_keys)
+        raise NotImplementedError, 'Sorry, you have to override length'
+      end
+
+      def verify
+        return context if context.failure?
+
+        if throw_error_predicate(keys)
+          Configuration.logger.error error_message
+          raise error_to_throw, error_message
+        end
+
+        context
+      end
+
+      def self.verify_keys(context, action, &block)
+        ReservedKeysVerifier.new(context, action).verify
+        ExpectedKeyVerifier.new(context, action).verify
+
+        block.call
+
+        PromisedKeyVerifier.new(context, action).verify
+      end
+    end
+
+    class ExpectedKeyVerifier < KeyVerifier
+      def type_name
+        "expected"
+      end
+
+      def keys
+        action.expected_keys
+      end
+
+      def error_to_throw
+        ExpectedKeysNotInContextError
+      end
+
+      def throw_error_predicate(keys)
+        !are_all_keys_in_context?(keys)
+      end
+    end
+
+    class PromisedKeyVerifier < KeyVerifier
+      def type_name
+        "promised"
+      end
+
+      def keys
+        action.promised_keys
+      end
+
+      def error_to_throw
+        PromisedKeysNotInContextError
+      end
+
+      def throw_error_predicate(keys)
+        !are_all_keys_in_context?(keys)
+      end
+    end
+
+    class ReservedKeysVerifier < KeyVerifier
+      def violated_keys
+        (action.promised_keys + action.expected_keys) & reserved_keys
+      end
+
+      def error_message
+        "promised or expected keys cannot be a " \
+        "reserved key: [#{format_keys(violated_keys)}]"
+      end
+
+      def keys
+        violated_keys
+      end
+
+      def error_to_throw
+        ReservedKeysInContextError
+      end
+
+      def throw_error_predicate(keys)
+        keys.any?
+      end
+
+      def reserved_keys
+        %i[message error_code current_action].freeze
+      end
+    end
+  end
+end

data/lib/functional-light-service/context.rb

@@ -0,0 +1,165 @@
+require 'active_support/deprecation'
+
+module FunctionalLightService
+  # rubocop:disable ClassLength
+  class Context < Hash
+    include FunctionalLightService::Prelude::Option
+    include FunctionalLightService::Prelude::Result
+    attr_accessor :outcome, :current_action
+
+    def initialize(context = {},
+                   outcome = Success(:message => '', :error => nil))
+      @outcome = outcome
+      @skip_remaining = false
+      context.to_hash.each { |k, v| self[k] = v }
+    end
+
+    def self.make(context = {})
+      unless context.is_a?(Hash) || context.is_a?(FunctionalLightService::Context)
+        msg = 'Argument must be Hash or FunctionalLightService::Context'
+        raise ArgumentError, msg
+      end
+
+      context = new(context) unless context.is_a?(Context)
+
+      context.assign_aliases(context.delete(:_aliases)) if context[:_aliases]
+      context
+    end
+
+    def add_to_context(values)
+      merge! values
+    end
+
+    def success?
+      @outcome.success?
+    end
+
+    def failure?
+      success? == false
+    end
+
+    def skip_remaining?
+      @skip_remaining
+    end
+
+    def reset_skip_remaining!
+      @outcome = Success(nil)
+      @skip_remaining = false
+    end
+
+    def message
+      @outcome.value.dig(:message)
+    end
+
+    def error_code
+      @outcome.value.dig(:error)
+    end
+
+    def succeed!(message = nil, options = {})
+      message = Configuration.localization_adapter.success(message,
+                                                           current_action,
+                                                           options)
+      @outcome = Success(:message => message)
+    end
+
+    def fail!(message = nil, options_or_error_code = {})
+      options_or_error_code ||= {}
+
+      if options_or_error_code.is_a?(Hash)
+        error_code = options_or_error_code.delete(:error_code)
+        options = options_or_error_code
+      else
+        error_code = options_or_error_code
+        options = {}
+      end
+
+      message = Configuration.localization_adapter.failure(message,
+                                                           current_action,
+                                                           options)
+
+      @outcome = Failure(:message => message, :error => error_code)
+    end
+
+    def fail_and_return!(*args)
+      fail!(*args)
+      throw(:jump_when_failed, *args)
+    end
+
+    def fail_with_rollback!(message = nil, error_code = nil)
+      fail!(message, error_code)
+      raise FailWithRollbackError
+    end
+
+    def skip_all!(message = nil)
+      warning_msg = "Using skip_all! has been deprecated, " \
+                    "please use `skip_remaining!` instead."
+      ActiveSupport::Deprecation.warn(warning_msg)
+
+      skip_remaining!(message)
+    end
+
+    def skip_remaining!(message = nil)
+      @outcome = Success(:message => message)
+      @skip_remaining = true
+    end
+
+    def stop_processing?
+      failure? || skip_remaining?
+    end
+
+    def define_accessor_methods_for_keys(keys)
+      return if keys.nil?
+
+      keys.each do |key|
+        next if respond_to?(key.to_sym)
+
+        define_singleton_method(key.to_s) { fetch(key) }
+        define_singleton_method("#{key}=") { |value| self[key] = value }
+      end
+    end
+
+    def assign_aliases(aliases)
+      @aliases = aliases
+
+      aliases.each_pair do |key, key_alias|
+        self[key_alias] = self[key]
+      end
+    end
+
+    def aliases
+      @aliases ||= {}
+    end
+
+    def [](key)
+      key = aliases.key(key) || key
+      return super(key)
+    end
+
+    def fetch(key, default = nil, &blk)
+      self[key] ||= if block_given?
+                      super(key, &blk)
+                    else
+                      super
+                    end
+    end
+
+    def inspect
+      "#{self.class}(#{self}, " \
+      + "success: #{success?}, " \
+      + "message: #{check_nil(message)}, " \
+      + "error_code: #{check_nil(error_code)}, " \
+      + "skip_remaining: #{@skip_remaining}, " \
+      + "aliases: #{@aliases}" \
+      + ")"
+    end
+
+    private
+
+    def check_nil(value)
+      return 'nil' unless value
+
+      "'#{value}'"
+    end
+  end
+  # rubocop:enable ClassLength
+end

data/lib/functional-light-service/errors.rb

@@ -0,0 +1,6 @@
+module FunctionalLightService
+  class FailWithRollbackError < StandardError; end
+  class ExpectedKeysNotInContextError < StandardError; end
+  class PromisedKeysNotInContextError < StandardError; end
+  class ReservedKeysInContextError < StandardError; end
+end