light-services 0.6.3 → 2.0.0.rc3

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# Collection to store arguments and outputs values
+module Light
+  module Services
+    module Collection
+      class Base
+        # Includes
+        extend Forwardable
+
+        # Settings
+        def_delegators :@storage, :key?, :to_h
+
+        def initialize(instance, storage = {})
+          @instance = instance
+          @storage = storage
+
+          return if storage.is_a?(Hash)
+
+          raise Light::Services::ArgTypeError, "#{instance.class} - arguments must be a Hash"
+        end
+
+        def set(key, value)
+          @storage[key] = value
+        end
+
+        def get(key)
+          @storage[key]
+        end
+
+        def [](key)
+          get(key)
+        end
+
+        def []=(key, value)
+          set(key, value)
+        end
+
+        def load_defaults
+          settings_collection.each do |name, settings|
+            next if !settings.default_exists || key?(name)
+
+            set(name, deep_dup(settings.default))
+          end
+        end
+
+        private
+
+        def deep_dup(object)
+          Marshal.load(Marshal.dump(object))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Collection to store outputs values
+module Light
+  module Services
+    module Collection
+      class Outputs < Base
+        private
+
+        def settings_collection
+          @instance.class.outputs
+        end
+      end
+    end
+  end
+end

data/lib/light/services/config.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Light
+  module Services
+    class << self
+      def configure
+        yield config
+      end
+
+      def config
+        @config ||= Config.new
+      end
+    end
+
+    class Config
+      # Constants
+      DEFAULTS = {
+        use_transactions: true,
+
+        load_errors: true,
+        break_on_error: true,
+        raise_on_error: false,
+        rollback_on_error: true,
+
+        load_warnings: true,
+        break_on_warning: false,
+        raise_on_warning: false,
+        rollback_on_warning: false
+      }.freeze
+
+      # Getters / Setters
+      attr_accessor :use_transactions,
+                    :load_errors, :break_on_error, :raise_on_error, :rollback_on_error,
+                    :load_warnings, :break_on_warning, :raise_on_warning, :rollback_on_warning
+
+      def initialize
+        reset_to_defaults!
+      end
+
+      def set(key, value)
+        instance_variable_set("@#{key}", value)
+      end
+
+      def get(key)
+        instance_variable_get("@#{key}")
+      end
+
+      def reset_to_defaults!
+        DEFAULTS.each do |key, value|
+          set(key, value)
+        end
+      end
+
+      def to_h
+        DEFAULTS.keys.map { |key| [key, get(key)] }.to_h
+      end
+
+      def merge(config)
+        to_h.merge(config)
+      end
+    end
+  end
+end

data/lib/light/services/exceptions.rb

@@ -3,7 +3,8 @@
 module Light
   module Services
     class Error < StandardError; end
-    class ParamRequired < Light::Services::Error; end
-    class ParamType < Light::Services::Error; end
+    class ArgTypeError < Error; end
+    class NoStepError < Error; end
+    class TwoConditions < Error; end
   end
 end

data/lib/light/services/messages.rb

@@ -1,80 +1,102 @@
 # frozen_string_literal: true
 
+# This class stores errors and warnings
 module Light
   module Services
     class Messages
-      def initialize
-        @storage = {}
+      def initialize(config)
+        @break = false
+        @config = config
+        @messages = {}
       end
 
-      def add(key, message, rollback: true)
-        storage[key] ||= []
-        storage[key] << message
+      def add(key, message, opts = {})
+        @messages[key] ||= []
+        @messages[key] += [*message]
 
-        rollback! if rollback
+        raise!(key, message)
+        break!(opts[:break])
+        rollback!(opts[:rollback])
       end
 
-      def from_record(record, rollback: true)
-        return unless record.errors.any?
+      def break?
+        @break
+      end
 
-        record.errors.messages.each do |key, messages|
-          messages.each do |message|
-            add(key, message, rollback: false)
+      def copy_from(entity, opts = {})
+        if defined?(ActiveRecord::Base) && entity.is_a?(ActiveRecord::Base)
+          copy_from(entity.errors.messages, opts)
+        elsif entity.respond_to?(:each)
+          entity.each do |key, message|
+            add(key, message, opts)
           end
+        else
+          # TODO: Update error
+          raise Light::Services::Error
         end
-
-        rollback! if rollback
       end
 
-      def from_service(service, rollback: true)
-        return unless service.errors.any?
-
-        service.errors.each do |key, message|
-          add(key, message, rollback: false)
+      def copy_to(entity)
+        if defined?(ActiveRecord::Base) && entity.is_a?(ActiveRecord::Base)
+          each do |key, message|
+            entity.errors.add(key, message)
+          end
+        elsif entity.is_a?(Hash)
+          each do |key, message|
+            entity[key] ||= []
+            entity[key] << message
+          end
+        else
+          # TODO: Update error
+          raise Light::Services::Error
         end
 
-        rollback! if rollback
+        entity
       end
 
-      def delete(key)
-        storage.delete(key)
-      end
+      def errors_to_record(record)
+        if !defined?(ActiveRecord::Base) || !record.is_a?(ActiveRecord::Base)
+          # TODO: Update error
+          raise Light::Services::Error
+        end
 
-      def blank?
-        storage.empty?
-      end
+        errors.each do |key, message|
+          record.errors.add(key, message)
+        end
 
-      def any?
-        !blank?
+        record
       end
 
-      def to_hash
-        storage
+      def method_missing(method, *args, &block)
+        if @messages.respond_to?(method)
+          @messages.public_send(method, *args, &block)
+        else
+          super
+        end
       end
 
-      def flatten
-        to_hash.flat_map do |key, messages|
-          messages.map do |message|
-            [key, message]
-          end
-        end
+      def respond_to_missing?(method, include_private = false)
+        @messages.respond_to?(method, include_private) || super
       end
 
-      def each
-        flatten.each do |key, message|
-          yield key, message
-        end
+      private
+
+      def break!(break_execution)
+        return unless break_execution.nil? ? @config[:break_on_add] : break_execution
+
+        @break = true
       end
 
-      alias to_h to_hash
+      def raise!(key, message)
+        return unless @config[:raise_on_add]
 
-      private
+        raise Light::Services::Error, "#{key.to_s.capitalize} #{message}"
+      end
 
-      # Getters / Setters
-      attr_accessor :storage
+      def rollback!(rollback)
+        return if !defined?(ActiveRecord::Rollback) || !(rollback.nil? ? @config[:rollback_on_add] : rollback)
 
-      def rollback!
-        raise ActiveRecord::Rollback if defined?(ActiveRecord::Rollback)
+        raise ActiveRecord::Rollback
       end
     end
   end

data/lib/light/services/settings/argument.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# This class defines settings for argument
+module Light
+  module Services
+    module Settings
+      class Argument
+        # Getters
+        attr_reader :name, :default_exists, :default, :context, :optional
+
+        def initialize(name, service_class, opts = {})
+          @name = name
+          @service_class = service_class
+
+          @type = opts.delete(:type)
+          @context = opts.delete(:context)
+          @default_exists = opts.key?(:default)
+          @default = opts.delete(:default)
+          @optional = opts.delete(:optional)
+
+          define_methods
+        end
+
+        def valid_type?(value)
+          return if !@type || [*@type].any? do |type|
+            if type == :boolean
+              value.is_a?(TrueClass) || value.is_a?(FalseClass)
+            else
+              value.is_a?(type)
+            end
+          end
+
+          raise Light::Services::ArgTypeError, "#{@service_class} argument `#{name}` must be " \
+                                               "a #{[*@type].join(', ')} (currently: #{value.class})"
+        end
+
+        private
+
+        def define_methods
+          name = @name
+
+          @service_class.define_method(@name) { @arguments.get(name) }
+          @service_class.define_method("#{@name}?") { !!@arguments.get(name) } # rubocop:disable Style/DoubleNegation
+          @service_class.define_method("#{@name}=") { |value| @arguments.set(name, value) }
+          @service_class.send(:private, "#{@name}=")
+        end
+      end
+    end
+  end
+end

data/lib/light/services/settings/output.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# This class defines settings for output
+module Light
+  module Services
+    module Settings
+      class Output
+        # Getters
+        attr_reader :name, :default_exists, :default
+
+        def initialize(name, service_class, opts = {})
+          @name = name
+          @service_class = service_class
+
+          @default_exists = opts.key?(:default)
+          @default = opts.delete(:default)
+
+          define_methods
+        end
+
+        private
+
+        def define_methods
+          name = @name
+
+          @service_class.define_method(@name) { @outputs.get(name) }
+          @service_class.define_method("#{@name}?") { !!@outputs.get(name) } # rubocop:disable Style/DoubleNegation
+          @service_class.define_method("#{@name}=") { |value| @outputs.set(name, value) }
+          @service_class.send(:private, "#{@name}=")
+        end
+      end
+    end
+  end
+end

data/lib/light/services/settings/step.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# This class defines settings for step
+module Light
+  module Services
+    module Settings
+      class Step
+        # Getters
+        attr_reader :name, :always
+
+        def initialize(name, service_class, opts = {})
+          @name = name
+          @service_class = service_class
+
+          @if     = opts[:if]
+          @unless = opts[:unless]
+          @always = opts[:always]
+
+          if @if && @unless
+            raise Light::Services::TwoConditions, "#{service_class} `if` and `unless` cannot be specified " \
+                                                  "for the step `#{name}` at the same time"
+          end
+
+          if @always && (@if || @unless)
+            raise Light::Services::Error, "#{service_class} `always` cannot be combined with `if` and `unless`"
+          end
+        end
+
+        def run(instance, benchmark: false)
+          return false unless run?(instance)
+
+          if instance.respond_to?(name, true)
+            if benchmark
+              time = Benchmark.ms do
+                instance.send(name)
+              end
+
+              instance.log "⏱️ Step #{name} took #{time}ms"
+            else
+              instance.send(name)
+            end
+
+            true
+          else
+            raise Light::Services::NoStepError, "Cannot find step `#{name}` in service `#{@service_class}`"
+          end
+        end
+
+        private
+
+        def run?(instance)
+          return false if instance.done?
+
+          if @if
+            check_condition(@if, instance)
+          elsif @unless
+            !check_condition(@unless, instance)
+          else
+            true
+          end
+        end
+
+        def check_condition(condition, instance)
+          case condition
+          when Symbol
+            instance.send(condition)
+          when Proc
+            condition.call
+          else
+            raise Light::Services::Error, "#{@service_class} condition should be a Symbol or Proc " \
+                                          "for the step `#{@name}` (currently: #{condition.class})"
+          end
+        end
+      end
+    end
+  end
+end