clear_logic 0.1.1

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'clear_logic'
+
+# 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(__FILE__)

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/clear_logic.gemspec

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'clear_logic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'clear_logic'
+  spec.version       = ClearLogic::VERSION
+  spec.authors       = ['bezrukavyi']
+  spec.email         = ['yaroslav.bezrukavyi@gmail.com']
+
+  spec.summary       = 'Clear result'
+  spec.description   = 'Clear result'
+  spec.homepage      = 'https://github.com/bezrukavyi/clear_logic'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['homepage_uri'] = spec.homepage
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'dry-matcher', '>= 0.7'
+  spec.add_dependency 'dry-monads', '>= 0.3.1'
+  spec.add_dependency 'dry-transaction', '>= 0.12.0'
+  spec.add_dependency 'dry-initializer', '>= 2.5.0'
+  spec.add_dependency 'dry-types', '>= 1.0.0'
+  spec.add_dependency 'dry-inflector'
+
+  spec.add_development_dependency 'bundler', '~> 1.17'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'ffaker'
+end

data/lib/clear_logic.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'json'
+require 'pry'
+
+require 'dry-types'
+require 'dry-initializer'
+require 'dry-transaction'
+require 'dry-matcher'
+require 'dry-monads'
+
+require 'clear_logic/logger/default'
+require 'clear_logic/logger/adapter'
+require 'clear_logic/errors/failure_error'
+require 'clear_logic/errors/catched_error'
+require 'clear_logic/version'
+require 'clear_logic/types'
+require 'clear_logic/result'
+require 'clear_logic/step_adapters/stride'
+require 'clear_logic/matcher'
+require 'clear_logic/context/builder'
+require 'clear_logic/service'
+
+module ClearLogic
+end

data/lib/clear_logic/context/builder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ClearLogic
+  class ContextBuilder
+    def self.call
+      Class.new do
+        extend ::Dry::Initializer
+
+        attr_reader :args
+        attr_accessor :catched_error, :failure_error, :service, :exit_success, :step
+
+        def initialize(*args)
+          @args = args
+          super(*args)
+        end
+
+        def [](key)
+          @additional_opts ||= {}
+          @additional_opts[key]
+        end
+
+        def []=(key, value)
+          @additional_opts ||= {}
+          @additional_opts[key] = value
+        end
+
+        def exit_success?
+          exit_success == true
+        end
+
+        def catched_error?
+          !catched_error.nil?
+        end
+
+        def failure_error?
+          !failure_error.nil?
+        end
+
+        def to_h
+          {
+            catched_error: catched_error,
+            failure_error: failure_error,
+            service: service.class,
+            exit_success: exit_success,
+            step: step,
+            options: @additional_opts,
+            args: args
+          }
+        end
+      end
+    end
+  end
+end

data/lib/clear_logic/errors/catched_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ClearLogic
+  class CatchedError
+    attr_reader :error
+
+    def initialize(error)
+      @error = error
+    end
+  end
+end

data/lib/clear_logic/errors/failure_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ClearLogic
+  class FailureError
+    attr_reader :status
+
+    def initialize(status)
+      @status = status
+    end
+  end
+end

data/lib/clear_logic/logger/adapter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ClearLogic
+  module Logger
+    class Adapter
+      attr_reader :service_class, :logger_class, :log_path
+
+      def initialize(service_class)
+        @service_class = service_class
+        @logger_class = service_class.logger_class
+        @log_path = service_class.logger_options[:log_path] || default_log_path
+      end
+
+      def logger
+        @logger ||= create_logger
+      end
+
+      private
+
+      def create_logger
+        system('mkdir', '-p', path) unless Dir.exist?(path)
+
+        logger_class.new(log_path)
+      end
+
+      def path
+        File.dirname(log_path)
+      end
+
+      def default_log_path
+        file_name = Dry::Inflector.new.underscore(service_class.name.gsub('::', '/'))
+        File.join(ENV['BUNDLE_GEMFILE'], "log/#{file_name}.log").gsub!('Gemfile/', '')
+      end
+    end
+  end
+end

data/lib/clear_logic/logger/default.rb

@@ -0,0 +1,24 @@
+module ClearLogic
+  module Logger
+    class Default < ::Logger
+      DATE_FORMAT = '%y-%m-%d %H:%M:%S.%3N '.freeze
+      FORMAT = "[%s#%d#%d] %5s -- %s: %s\n".freeze
+
+      def format_message(severity, time, progname, context)
+        thread_id = Thread.current.object_id % 100_000
+
+        format(FORMAT, format_datetime(time), Process.pid, thread_id, severity, progname, pretty_view(context))
+      end
+
+      private
+
+      def format_datetime(time)
+        time.strftime(DATE_FORMAT)
+      end
+
+      def pretty_view(context)
+        JSON.pretty_generate(context.to_h)
+      end
+    end
+  end
+end

data/lib/clear_logic/matcher.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ClearLogic
+  class Matcher
+    CASES = %i[success failure].freeze
+
+    def self.call(*args)
+      new.matcher.call(*args) { |on| yield(on) }
+    end
+
+    def matcher
+      dry_cases = CASES.each_with_object({}) do |one_case, case_list|
+        case_list[one_case] = send("#{one_case}_case")
+      end
+
+      Dry::Matcher.new(dry_cases)
+    end
+
+    private
+
+    def success_case
+      Dry::Matcher::Case.new(
+        match: ->(result) { result.success? },
+        resolve: ->(result) { result }
+      )
+    end
+
+    def failure_case
+      Dry::Matcher::Case.new(
+        match: ->(result, *patterns) { patterns.any? ? case_patterns(result, patterns) : result.failure? },
+        resolve: ->(result) { result }
+      )
+    end
+
+    def case_patterns(result, patterns)
+      patterns.any? do |pattern|
+        return false unless respond_to?("#{pattern}_pattern", private: true)
+
+        send("#{pattern}_pattern", result)
+      end
+    end
+
+    ClearLogic::Result::DEFAULT_ERRORS.each do |error_type|
+      define_method "#{error_type}_pattern" do |result|
+        return false unless result.failure?
+
+        result.context.respond_to?(:failure_error) &&
+          !result.context.failure_error.nil? &&
+          result.context.failure_error.status == error_type
+      end
+    end
+  end
+end

data/lib/clear_logic/result.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+Dry::Monads::Result::Success.class_eval do
+  alias context success
+end
+
+Dry::Monads::Result::Failure.class_eval do
+  alias context failure
+end
+
+module ClearLogic
+  module Result
+    DEFAULT_ERRORS = %i[
+      unauthorized
+      forbidden
+      not_found
+      invalid
+    ].freeze
+
+    private
+
+    def self.included(base)
+      base.extend(ClassMethdos)
+
+      base.errors(*DEFAULT_ERRORS)
+    end
+
+    module ClassMethdos
+      def errors(*errors_methods)
+        errors_methods.each do |error_type|
+          define_method(error_type) do |context|
+            context.failure_error ||= ClearLogic::FailureError.new(error_type)
+
+            failure(context)
+          end
+
+          private error_type
+        end
+      end
+    end
+
+    def success(context)
+      Dry::Monads::Result::Success.new(context)
+    end
+
+    def exit_success(context)
+      context.exit_success = true
+      success(context)
+    end
+
+    def failure(context)
+      Dry::Monads::Result::Failure.new(context)
+    end
+  end
+end

data/lib/clear_logic/service.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ClearLogic
+  class Service
+    include Dry::Transaction
+    include ClearLogic::Result
+
+    class << self
+      attr_accessor :context_class, :logger_instance, :logger_options,
+                    :logger_class
+
+      def call(*args)
+        new.call(args)
+      end
+
+      def build_context
+        self.context_class = ClearLogic::ContextBuilder.call
+      end
+
+      def context(name, type = nil, **options)
+        context_class.class_eval do
+          method = options.delete(:as) || :option
+          send(method, name, type, **options)
+        end
+      end
+
+      def logger(logger_class, log_all: false, log_path: nil)
+        self.logger_options = { log_all: log_all, log_path: log_path }
+        self.logger_class = logger_class
+        self.logger_instance = ClearLogic::Logger::Adapter.new(self).logger
+      end
+
+      def inherited(base)
+        base.class_eval do
+          attr_reader :context
+
+          build_context
+
+          logger ClearLogic::Logger::Default
+
+          step :initialize_context
+
+          private
+
+          def initialize_context(args)
+            @context = self.class.context_class.new(*args.flatten)
+            context.service = self
+
+            success(context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clear_logic/step_adapters/stride.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'dry/transaction/errors'
+
+module ClearLogic
+  module StepAdapters
+    class Stride
+      include Dry::Monads::Result::Mixin
+      include ClearLogic::Result
+
+      attr_reader :operation, :options, :args, :context
+
+      def call(operation, options, args)
+        @operation = operation
+        @options = options
+        @args = args
+        @context = args.flatten.first
+
+        options[:rescue] ||= {}
+
+        context.step = options[:step_name]
+
+        return success(context) if context.exit_success?
+
+        result = operation.call(context)
+
+        log_result
+
+        return result if result.success?
+
+        failure_method
+      rescue *Array(options[:rescue].keys) => e
+        catch_error(e)
+      end
+
+      def catch_error(error)
+        context.catched_error = error
+
+        log_result
+
+        rescue_method = options[:rescue][error.class]
+        rescue_method ? context.service.send(rescue_method, context) : failure(context)
+      end
+
+      def log_result
+        return unless options[:log] || context.service.class.logger_options[:log_all]
+
+        context.service.class.logger_instance.info(context)
+      end
+
+      def failure_method
+        options[:failure] ? context.service.send(options[:failure], context) : failure(context)
+      end
+    end
+  end
+end
+
+Dry::Transaction::StepAdapters.register(:stride, ClearLogic::StepAdapters::Stride.new)