servitium 1.2.20

data/lib/servitium/service.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require_relative 'transactional_mixin'
+require_relative 'capture_exceptions_mixin'
+
+module Servitium
+  class Service
+    include ActiveSupport::Callbacks
+    include TransactionalMixin
+    include CaptureExceptionsMixin
+    include I18n
+
+    attr_reader :context, :raise_on_error
+
+    alias ctx context
+
+    define_callbacks :commit
+    define_callbacks :perform
+    define_callbacks :failure
+    define_callbacks :async_success
+    define_callbacks :async_failure
+    private_class_method :new
+
+    delegate :transactional, to: :class
+    delegate :capture_exceptions, to: :class
+    delegate :model_name, to: :context
+
+    def initialize(*args)
+      @raise_on_error = false
+      @command = args.first.is_a?(Symbol) ? args.shift : :perform
+      @context = context_class.new(*args)
+      super()
+    end
+
+    private
+
+    def call
+      if transactional && defined?(ActiveRecord::Base)
+        ActiveRecord::Base.transaction(requires_new: true) do
+          exec
+          # This will only rollback the changes of the service, SILENTLY, however the context will be failed? already.
+          # This is the most close to expected behaviour this can get.
+          raise ActiveRecord::Rollback if context.failed?
+        end
+
+        context
+      else
+        exec
+      end
+    end
+
+    def call!
+      @raise_on_error = true
+      call
+    end
+
+    def context_class
+      self.class.context_class || Servitium::Context
+    end
+
+    def exec
+      run_callbacks :perform do
+        send(@command)
+      rescue Servitium::ContextFailure => e
+        raise_if_needed(e)
+      rescue StandardError => e
+        # If capture exceptions is true, eat the exception and set the context errors.
+        raise unless capture_exceptions
+
+        begin
+          context.fail!(:base, e.message)
+        rescue Servitium::ContextFailure => e
+          # Eat this as well, we don't want to raise here, capture exceptions is true.
+        end
+      end
+      raise_if_needed
+      context
+    end
+
+    def raise_on_error?
+      @raise_on_error
+    end
+
+    def raise_if_needed(e = nil)
+      raise e if e.present? && e.context.object_id != context.object_id
+      return unless raise_on_error?
+
+      if e
+        raise e
+      elsif context.errors.present?
+        errors = context.errors.full_messages.join(', ')
+        log :error, "raising: #{errors}"
+        raise StandardError, errors
+      end
+    end
+
+    def log(level, message)
+      return unless defined? Rails.logger
+
+      Rails.logger.send level, "#{self.class.name}: #{message}"
+    end
+
+    def after_commit
+      run_callbacks :commit do
+      end
+    end
+
+    def failure
+      run_callbacks :failure do
+      end
+    end
+
+    def async_success
+      run_callbacks :async_success do
+      end
+    end
+
+    def async_failure
+      run_callbacks :async_failure do
+      end
+    end
+
+    class << self
+      # Main point of entry for services, will raise in case of errors
+      def perform!(*args)
+        inst = new(*args)
+
+        begin
+          inst.context.validate!(:in) if inst.context.class.inbound_scope_used
+          inst.context.validate!
+          inst.context.instance_variable_set(:@called, true)
+          inst.send(:call!)
+          inst.context.validate!(:out) if inst.context.errors.blank? && inst.context.class.inbound_scope_used
+          inst.send(:after_commit) unless inst.context.failed?
+        ensure
+          inst.send(:failure) if inst.context.failed?
+        end
+
+        inst.context
+      end
+
+      # Main point of entry for services
+      def perform(*args)
+        call(*args).context
+      end
+
+      # Call the service returning the service instance
+      def call(*args)
+        inst = new(*args)
+
+        valid_in = inst.context.valid?
+        valid_in &&= inst.context.valid?(:in) if inst.context.class.inbound_scope_used
+
+        if valid_in
+          inst.context.instance_variable_set(:@called, true)
+          inst.send(:call)
+          inst.context.valid?(:out) if inst.context.errors.blank? && inst.context.class.inbound_scope_used
+          inst.send(:after_commit) unless inst.context.failed?
+        end
+
+        inst.send(:failure) if inst.context.failed?
+
+        inst
+      end
+
+      # Perform this service async
+      def perform_later(*args)
+        inst = new(*args)
+
+        valid_in = inst.context.valid?
+        valid_in &&= inst.context.valid?(:in) if inst.context.class.inbound_scope_used
+
+        if valid_in
+          inst.context.instance_variable_set(:@called, true)
+          Servitium::ServiceJob.perform_later(name, inst.context.attributes_hash)
+        end
+
+        inst.context
+      end
+
+      def queue_name
+        'default'
+      end
+
+      # Callbacks
+      def after_commit(*filters, &block)
+        set_callback(:commit, :after, *filters, &block)
+      end
+
+      def before_perform(*filters, &block)
+        set_callback(:perform, :before, *filters, &block)
+      end
+
+      def around_perform(*filters, &block)
+        set_callback(:perform, :around, *filters, &block)
+      end
+
+      def after_perform(*filters, &block)
+        set_callback(:perform, :after, *filters, &block)
+      end
+
+      def after_failure(*filters, &block)
+        set_callback(:failure, :after, *filters, &block)
+      end
+
+      def around_async_success(*filters, &block)
+        set_callback(:async_success, :around, *filters, &block)
+      end
+
+      def around_async_failure(*filters, &block)
+        set_callback(:async_failure, :around, *filters, &block)
+      end
+
+      def after_async_success(*filters, &block)
+        set_callback(:async_success, :after, *filters, &block)
+      end
+
+      def after_async_failure(*filters, &block)
+        set_callback(:async_failure, :after, *filters, &block)
+      end
+
+      def context_class
+        context_class_name.safe_constantize
+      end
+
+      def context_class_name
+        name.gsub('Service', 'Context')
+      end
+
+      def context_class!
+        return context_class if context_class
+
+        context_class_parts = context_class_name.split('::')
+        context_class_name_part = context_class_parts.pop
+        context_module_name = context_class_parts.join('::')
+        context_module = context_module_name.present? ? context_module_name.constantize : Object
+
+        context_module.const_set(context_class_name_part, Class.new(context_base_class_name.constantize))
+        context_class
+      end
+
+      # Get the base class for new contexts defined using context blocks
+      # Defaults to Servitium::Context
+      def context_base_class_name
+        @@_context_base_class_name ||= 'Servitium::Context'
+      end
+
+      # Override the base class for contexts defined using context blocks, you can use this to
+      # change the base class to your own ApplicationContext
+      def context_base_class_name=(base_class)
+        @@_context_base_class_name = base_class
+      end
+
+      def context(*args, &block)
+        return initialized_context(*args) unless block_given?
+
+        begin
+          context_class!.new
+        rescue StandardError
+          nil
+        end
+        context_class!.class_eval(&block)
+      end
+
+      def initialized_context(*args)
+        context_class.new(*args)
+      end
+    end
+  end
+end

data/lib/servitium/service_job.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Servitium
+  class ServiceJob < ActiveJob::Base
+    queue_as { queue_name }
+
+    def perform(class_name, *args)
+      service = class_name.constantize.call(*args)
+
+      if service.context.success?
+        service.send(:async_success)
+      else
+        service.send(:async_failure)
+      end
+    end
+
+    def queue_name
+      arguments.first.constantize.queue_name
+    end
+  end
+end

data/lib/servitium/sub_contexts.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Servitium
+  module SubContexts
+    def sub_context(name)
+      if name.to_s.singularize == name.to_s
+        define_method("#{name}_attributes=") do |attributes|
+          klass = "#{self.class.name}::#{name.to_s.camelize}".safe_constantize
+
+          writer = "#{name}="
+          inst = klass.new(attributes)
+          inst.supercontext = self
+
+          send writer, inst if respond_to? writer
+
+          @subcontexts ||= {}
+          @subcontexts[name] = inst
+
+          inst
+        end
+
+        define_method("#{name}=") do |attributes|
+          klass = "#{self.class.name}::#{name.to_s.camelize}".safe_constantize
+          inst = if attributes.is_a? klass
+                   attributes
+                 else
+                   inst = klass.new(attributes)
+                   inst.supercontext = self
+                   inst
+                 end
+
+          instance_variable_set("@#{name}".to_sym, inst)
+
+          @subcontexts ||= {}
+          @subcontexts[name] = inst
+
+          inst
+        end
+      else
+        define_method("#{name}_attributes=") do |attributes|
+          klass = "#{self.class.name}::#{name.to_s.singularize.camelize}".safe_constantize
+
+          if attributes.is_a?(Hash) || attributes.is_a?(ActionController::Parameters)
+            keys = attributes.keys
+            attributes = (if keys.reject { |k| k == 'TEMPLATE' }.all? { |k| k.to_i.to_s == k }
+                            attributes.reject do |k|
+                              k == 'TEMPLATE'
+                            end.values
+                          end)
+          end
+
+          result = []
+          attributes.each do |params|
+            next if params['_destroy'] == '1' || params[:_destroy] == '1'
+
+            inst = klass.new(params)
+            inst.supercontext = self
+            result.push(inst)
+          end
+          writer = "#{name}="
+          send writer, result if respond_to? writer
+
+          @subcontexts ||= {}
+          @subcontexts[name] = result
+
+          result
+        end
+
+        define_method("#{name}=") do |attributes|
+          klass = "#{self.class.name}::#{name.to_s.singularize.camelize}".safe_constantize
+          result = if attributes.is_a?(Array) && attributes.all? { |a| a.instance_of?(klass) }
+                     attributes
+                   else
+                     if attributes.is_a?(Hash) || attributes.is_a?(ActionController::Parameters)
+                       attributes = (attributes.values if attributes.keys.all? { |k| k.to_i.to_s == k })
+                     end
+
+                     result = []
+                     attributes.each do |params|
+                       inst = klass.new(params)
+                       inst.supercontext = self
+                       result.push(inst)
+                     end
+                     result
+                   end
+
+          instance_variable_set("@#{name}".to_sym, result)
+
+          @subcontexts ||= {}
+          @subcontexts[name] = result
+
+          result
+        end
+      end
+
+      if name.to_s.singularize == name.to_s
+        define_method(name.to_s) do
+          instance_variable_get("@#{name}".to_sym) if instance_variable_defined?("@#{name}".to_sym)
+        end
+      else
+        define_method(name.to_s) do
+          value = instance_variable_get("@#{name}".to_sym) if instance_variable_defined?("@#{name}".to_sym)
+          value ||= []
+          value
+        end
+      end
+
+      @attributes[name.to_s] = ActiveAttr::AttributeDefinition.new(name, {})
+    end
+  end
+end

data/lib/servitium/transactional_mixin.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Servitium
+  module TransactionalMixin
+    class << self
+      def included(base)
+        base.extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def transactional(value = nil)
+        @transactional = value if value
+        @transactional = nil unless defined?(@transactional)
+        if @transactional.nil?
+          @transactional = if superclass < Servitium::Service
+                             superclass.transactional
+                           else
+                             false
+                           end
+        end
+        @transactional
+      end
+    end
+  end
+end

data/lib/servitium/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Servitium
+  VERSION = "1.2.20"
+end

data/lib/servitium.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'active_attr'
+require 'active_support'
+require 'action_controller'
+require 'active_job'
+
+require 'servitium/error'
+require 'servitium/context_failure'
+require 'servitium/i18n'
+require 'servitium/sub_contexts'
+require 'servitium/scoped_attributes'
+require 'servitium/context_model'
+require 'servitium/context'
+require 'servitium/service_job'
+require 'servitium/service'
+require 'servitium/version'
+
+require 'servitium/rails' if defined?(::Rails)

data/lib/tasks/servitium_tasks.rake

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'active_support/inflector'
+
+namespace :servitium do
+  desc 'Convert localization keys'
+  task :convert_keys do
+    locs = YAML.load(File.read('./config/locales/en.yml'))
+    locs['en']['services'].each_key do |service|
+      locs['en'][service[0..-9].pluralize] = { 'service' => locs['en']['services'][service].dup }
+    end
+
+    File.open('./config/locales/en.yml', 'w') do |f|
+      f.write YAML.dump(locs)
+    end
+  end
+end

data/servitium.gemspec

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'lib/servitium/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'servitium'
+  spec.version       = Servitium::VERSION
+  spec.authors       = ['Tom de Grunt']
+  spec.email         = ['tom@degrunt.nl']
+
+  spec.summary       = 'Service objects'
+  spec.description   = 'An implementation of the command pattern for Ruby'
+  spec.homepage      = 'https://entropydecelerator.com/components/servitium'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.6.5')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://code.entropydecelerator.com/components/servitium'
+
+  # 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 'active_attr', '>= 0.15'
+  spec.add_dependency 'activejob', '> 5.1'
+  spec.add_dependency 'activemodel', '> 5.1'
+  spec.add_dependency 'activerecord', '> 5.1'
+  spec.add_dependency 'activesupport', '> 5.1'
+  spec.add_dependency 'actionpack', '> 5.1'
+  spec.add_dependency 'i18n', '>= 0.7'
+
+  spec.add_development_dependency 'auxilium', '>= 3'
+  spec.add_development_dependency 'minitest', '~> 5.11'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.1'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-rails', '~> 0.3'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rubocop', '~> 0.79'
+  spec.add_development_dependency 'sqlite3', '~> 1.4'
+end