light-services 0.6.0 → 2.0.0.rc1

data/Rakefile

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

data/bin/console

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'bundler/setup'
-require 'light/services'
+require "bundler/setup"
+require "light/services"
 
 # 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.
@@ -11,5 +11,5 @@ require 'light/services'
 # require "pry"
 # Pry.start
 
-require 'irb'
-IRB.start
+require "irb"
+IRB.start(__FILE__)

data/lib/light/services.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 
-require 'light/services/version'
-require 'light/services/exceptions'
-require 'light/services/messages'
-require 'light/services/parameters'
-require 'light/services/outputs'
-require 'light/services/callbacks'
-require 'light/services/base'
+require "light/services/config"
+require "light/services/version"
+require "light/services/exceptions"
+require "light/services/base"
 
 module Light
   module Services

data/lib/light/services/base.rb

@@ -1,64 +1,176 @@
 # frozen_string_literal: true
 
+require "light/services/messages"
+require "light/services/base_with_context"
+
+require "light/services/settings/step"
+require "light/services/settings/output"
+require "light/services/settings/argument"
+
+require "light/services/collection/base"
+require "light/services/collection/outputs"
+require "light/services/collection/arguments"
+
+require "light/services/class_based_collection/base"
+require "light/services/class_based_collection/mount"
+
+# Base class for all service objects
 module Light
   module Services
     class Base
       # Includes
-      include Light::Services::Parameters
-      include Light::Services::Outputs
-      include Light::Services::Callbacks
+      extend ClassBasedCollection::Mount
+
+      # Settings
+      mount_class_based_collection :steps,     item_class: Settings::Step,     shortcut: :step
+      mount_class_based_collection :outputs,   item_class: Settings::Output,   shortcut: :output
+      mount_class_based_collection :arguments, item_class: Settings::Argument, shortcut: :arg, allow_redefine: true
+
+      # Arguments
+      # TODO: Rename internal arguments
+      arg :benchmark, default: false
+      arg :deepness, default: 0, context: true
+
+      # Steps
+      step :load_defaults_and_validate
+      step :log_header, if: :benchmark?
 
       # Getters
-      attr_reader :errors, :warnings
+      attr_reader :outputs, :arguments, :errors, :warnings
 
-      def initialize(args = {})
-        @args = args
+      def initialize(args = {}, config = {}, parent_service = nil)
+        @config = Light::Services.config.merge(config)
+        @parent_service = parent_service
 
-        initialize_params
-        initialize_outputs
+        @outputs = Collection::Outputs.new(self)
+        @arguments = Collection::Arguments.new(self, args)
 
-        @errors   = Light::Services::Messages.new
-        @warnings = Light::Services::Messages.new
-      end
+        @launched_steps = []
 
-      def call
-        within_transaction { run_service }
+        initialize_errors
+        initialize_warnings
       end
 
       def success?
-        errors.blank?
+        !errors?
       end
 
-      def any_warnings?
-        warnings.any?
+      def failed?
+        errors?
+      end
+
+      def errors?
+        @errors.any?
+      end
+
+      def warnings?
+        @warnings.any?
+      end
+
+      def call
+        time = Benchmark.ms do
+          run_steps
+          run_steps_with_always
+
+          copy_warnings_to_parent_service
+          copy_errors_to_parent_service
+        end
+
+        return unless benchmark
+
+        log "🟢 Finished #{self.class} in #{time}ms"
+        puts
       end
 
       class << self
-        def call(args = {})
+        # TODO: Create `run!`
+        def run(args = {})
           new(args).tap(&:call)
         end
 
-        alias run call
+        def with(service_or_config = {}, config = {})
+          service = service_or_config.is_a?(Hash) ? nil : service_or_config
+          config = service ? config : service_or_config
+
+          BaseWithContext.new(self, service, config)
+        end
+      end
+
+      # TODO: Add possibility to specify logger
+      def log(message)
+        puts "#{'  ' * deepness}→ #{message}"
       end
 
       private
 
-      # Getters
-      attr_reader :args
+      def initialize_errors
+        @errors = Messages.new(
+          break_on_add: @config[:break_on_error],
+          raise_on_add: @config[:raise_on_error],
+          rollback_on_add: @config[:use_transactions] && @config[:rollback_on_error]
+        )
+      end
 
-      def run_service
-        run_callbacks(:before)
-        run if success?
-        run_callbacks(:after) if success?
-        run_callbacks(:finally, force_run: true)
-        success?
+      def initialize_warnings
+        @warnings = Messages.new(
+          break_on_add: @config[:break_on_warning],
+          raise_on_add: @config[:raise_on_warning],
+          rollback_on_add: @config[:use_transactions] && @config[:rollback_on_warning]
+        )
       end
 
-      def within_transaction
-        if defined?(ActiveRecord::Base)
-          ActiveRecord::Base.transaction do
-            yield
+      def run_steps
+        within_transaction do
+          self.class.steps.each do |name, step|
+            @launched_steps << name if step.run(self, benchmark: benchmark)
+
+            break if @errors.break? || @warnings.break?
           end
+        end
+      end
+
+      # Run steps with parameter `always` if they weren't launched because of errors/warnings
+      def run_steps_with_always
+        self.class.steps.each do |name, step|
+          next if !step.always || @launched_steps.include?(name)
+
+          @launched_steps << name if step.run(self)
+        end
+      end
+
+      def copy_warnings_to_parent_service
+        return if !@parent_service || !@config[:load_warnings]
+
+        @parent_service.warnings.copy_from(
+          @warnings,
+          break: @config[:self_break_on_warning],
+          rollback: @config[:self_rollback_on_warning]
+        )
+      end
+
+      def copy_errors_to_parent_service
+        return if !@parent_service || !@config[:load_errors]
+
+        @parent_service.errors.copy_from(
+          @errors,
+          break: @config[:self_break_on_error],
+          rollback: @config[:self_rollback_on_error]
+        )
+      end
+
+      def load_defaults_and_validate
+        @outputs.load_defaults
+        @arguments.load_defaults
+        @arguments.validate!
+      end
+
+      def log_header
+        log "🏎 Run service #{self.class}"
+      end
+
+      def within_transaction
+        if @config[:use_transactions] && defined?(ActiveRecord::Base)
+          ActiveRecord::Base.transaction(requires_new: true) { yield }
         else
           yield
         end

data/lib/light/services/base_with_context.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# This class allows to run service object with context (parent class and custom config)
+module Light
+  module Services
+    class BaseWithContext
+      def initialize(service_class, parent_service, config)
+        @service_class = service_class
+        @config = config
+        @parent_service = parent_service
+
+        return if parent_service.nil? || parent_service.is_a?(Light::Services::Base)
+
+        raise Light::Services::ArgTypeError, "#{parent_service.class} - must be a subclass of Light::Services::Base"
+      end
+
+      # TODO: Create `run!`
+      def run(args = {})
+        @service_class.new(extend_arguments(args), @config, @parent_service).tap(&:call)
+      end
+
+      private
+
+      def extend_arguments(args)
+        # TODO: Do we need `.dup` here?
+        args = @parent_service.arguments.extend_with_context(args) if @parent_service
+        args[:deepness] += 1 if args[:deepness]
+
+        args
+      end
+    end
+  end
+end

data/lib/light/services/class_based_collection/base.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# Create class based collections for storing arguments settings, steps settings and outputs settings
+#
+# General functionality:
+#   1. Collection automatically loads data from parent classes
+#   2. It's possible to redefine items if needed (e.g. arguments)
+#   3. We can add items into collection after or before another items
+#
+module Light
+  module Services
+    module ClassBasedCollection
+      class Base
+        # TODO: Add `prepend: true`
+        def initialize(item_class, allow_redefine)
+          @item_class = item_class
+          @allow_redefine = allow_redefine
+          @collection = {}
+        end
+
+        def add(klass, name, opts = {})
+          @collection[klass] ||= all_from_superclass(klass)
+
+          validate_name!(klass, name)
+          validate_opts!(klass, name, opts)
+
+          item = @item_class.new(name, klass, opts)
+
+          if opts[:before] || opts[:after]
+            insert_item(klass, name, opts, item)
+          else
+            @collection[klass][name] = item
+          end
+        end
+
+        def find_index(klass, name)
+          index = @collection[klass].keys.index(name)
+
+          return index if index
+
+          # TODO: Update `NoStepError` because it maybe not only step
+          raise Light::Services::NoStepError, "Cannot find #{@item_class} `#{name}` in service #{klass}"
+        end
+
+        def remove(klass, name)
+          @collection[klass] ||= all_from_superclass(klass)
+          @collection[klass].delete(name)
+        end
+
+        def all(klass)
+          @collection[klass] || all_from_superclass(klass)
+        end
+
+        private
+
+        def all_from_superclass(klass)
+          if klass.superclass <= Light::Services::Base
+            all(klass.superclass).dup
+          else
+            {}
+          end
+        end
+
+        def validate_name!(klass, name)
+          if !@allow_redefine && all(klass).key?(name)
+            # TODO: Update error class
+            raise Light::Services::Error, "#{@item_class} with name `#{name}` already exists in service #{klass}"
+          end
+        end
+
+        def validate_opts!(klass, name, opts)
+          if opts[:before] && opts[:after]
+            # TODO: Update error class
+            raise Light::Services::Error, "You cannot specify `before` and `after` " \
+                                          "for #{@item_class} `#{name}` in service #{klass} at the same time"
+          end
+        end
+
+        def insert_item(klass, name, opts, item)
+          index = find_index(klass, opts[:before] || opts[:after])
+          index = opts[:before] ? index : index + 1
+
+          @collection[klass] = @collection[klass].to_a.insert(index, [name, item]).to_h
+        end
+      end
+    end
+  end
+end

data/lib/light/services/class_based_collection/mount.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# This class allows to mount class based collections to service objects
+#
+# Usage:
+#
+#   mount_class_based_collection :steps,     klass: Settings::Step,     shortcut: :step
+#   mount_class_based_collection :outputs,   klass: Settings::Output,   shortcut: :output
+#   mount_class_based_collection :arguments, klass: Settings::Argument, shortcut: :arg, allow_redefine: true
+#
+module Light
+  module Services
+    module ClassBasedCollection
+      module Mount
+        def mount_class_based_collection(collection_name, item_class:, shortcut:, allow_redefine: false)
+          class_variable_set("@@#{collection_name}", ClassBasedCollection::Base.new(item_class, allow_redefine))
+
+          define_singleton_method shortcut do |item_name, opts = {}|
+            class_variable_get("@@#{collection_name}").add(self, item_name, opts)
+          end
+
+          define_singleton_method "remove_#{shortcut}" do |item_name|
+            class_variable_get("@@#{collection_name}").remove(self, item_name)
+          end
+
+          define_singleton_method collection_name do
+            class_variable_get("@@#{collection_name}").all(self)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/light/services/collection/arguments.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Collection to store, merge and validate arguments
+module Light
+  module Services
+    module Collection
+      class Arguments < Base
+        def extend_with_context(args)
+          settings_collection.each do |name, settings|
+            next if !settings.context || args.key?(name) || !key?(name)
+
+            args[settings.name] = get(name)
+          end
+
+          args
+        end
+
+        def validate!
+          settings_collection.each do |name, settings|
+            next if settings.optional && (!key?(name) || get(name).nil?)
+
+            settings.valid_type?(get(name))
+          end
+        end
+
+        private
+
+        def settings_collection
+          @instance.class.arguments
+        end
+      end
+    end
+  end
+end