light-services 0.5.4 → 2.0.0.beta1

data/lib/light/services/callbacks.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Light
-  module Services
-    module Callbacks
-      def self.included(base)
-        base.extend ClassMethods
-        base.class_eval do
-          class << self
-            attr_accessor :callbacks
-          end
-        end
-      end
-
-      private
-
-      def run_callbacks(type, options = {})
-        callbacks_by(type).each do |callback|
-          break if !success? && !options[:force_run]
-          send(callback[:method_name])
-        end
-      end
-
-      def callbacks_by(type)
-        all_callbacks.select { |callback| callback[:type] == type }
-      end
-
-      def all_callbacks
-        return @_all_callbacks if defined?(@_all_callbacks)
-        @_all_callbacks = self.class.ancestors.select { |klass| klass.ancestors.include?(::Light::Services::Base) }
-                              .map(&:callbacks).compact.reverse.flatten.uniq
-      end
-
-      module ClassMethods
-        def before(method_name)
-          set_callback(:before, method_name)
-        end
-
-        def after(method_name)
-          set_callback(:after, method_name)
-        end
-
-        def finally(method_name)
-          set_callback(:finally, method_name)
-        end
-
-        def set_callback(type, method_name)
-          self.callbacks ||= []
-          self.callbacks << { type: type, method_name: method_name }
-        end
-      end
-    end
-  end
-end

data/lib/light/services/outputs.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Light
-  module Services
-    module Outputs
-      def self.included(base)
-        base.extend ClassMethods
-        base.class_eval do
-          class << self
-            attr_accessor :outputs
-          end
-        end
-      end
-
-      # Getters
-      attr_reader :outputs
-
-      private
-
-      # Setters
-      attr_writer :outputs
-
-      def initialize_outputs
-        self.outputs = {}
-
-        all_outputs.each do |options|
-          store_output(options)
-        end
-
-        generate_outputs_methods
-      end
-
-      def all_outputs
-        return @_all_outputs if defined?(@_all_outputs)
-        @_all_outputs = self.class.ancestors.select { |klass| klass.ancestors.include?(::Light::Services::Base) }
-                            .map(&:outputs).compact.flatten.uniq
-      end
-
-      def store_output(options)
-        output_name  = options[:name]
-        output_value = options[:value]
-
-        outputs[output_name] = output_value
-      end
-
-      def generate_outputs_methods
-        outputs.keys.each do |output_name|
-          define_singleton_method output_name do
-            outputs[output_name]
-          end
-
-          define_singleton_method "#{output_name}=" do |value|
-            outputs[output_name] = value
-          end
-        end
-      end
-
-      module ClassMethods
-        def output(name, value = nil, options = {})
-          self.outputs ||= []
-          self.outputs << {
-            name:   name,
-            value:  value,
-            public: options.fetch(:private, false)
-          }
-        end
-      end
-    end
-  end
-end

data/lib/light/services/parameters.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-module Light
-  module Services
-    module Parameters
-      def self.included(base)
-        base.extend ClassMethods
-        base.class_eval do
-          class << self
-            attr_accessor :parameters
-          end
-        end
-      end
-
-      # Getters
-      attr_reader :parameters
-
-      private
-
-      # Setters
-      attr_writer :parameters
-
-      def initialize_params
-        self.parameters = {}
-
-        all_parameters.each do |options|
-          validate_parameter(options)
-          store_parameter(options)
-        end
-
-        generate_parameters_methods
-      end
-
-      def all_parameters
-        return @_all_parameters if defined?(@_all_parameters)
-        @_all_parameters = self.class.ancestors.select { |klass| klass.ancestors.include?(::Light::Services::Base) }
-                               .map(&:parameters).compact.flatten.uniq
-      end
-
-      def validate_parameter(options)
-        if parameter_required?(options)
-          raise Light::Services::ParamRequired, "Parameter \"#{options[:name]}\" is required"
-        end
-
-        return unless parameter_wrong_type?(options)
-
-        raise Light::Services::ParamType, "Type of \"#{options[:name]}\" must be \"#{options[:type]}\""
-      end
-
-      def parameter_required?(options)
-        !args.key?(options[:name]) && options[:required] && !options[:allow_nil]
-      end
-
-      def parameter_wrong_type?(options)
-        value = args[options[:name]]
-
-        wrong_type    = options[:type] && !options[:type].include?(value.class)
-        not_allow_nil = !options[:allow_nil] || (options[:allow_nil] && !value.nil?)
-
-        wrong_type && not_allow_nil
-      end
-
-      def store_parameter(options)
-        parameter_name = options[:name]
-        parameter_value = args[parameter_name]
-
-        parameters[parameter_name] = parameter_value
-      end
-
-      def generate_parameters_methods
-        parameters.keys.each do |parameter_name|
-          define_singleton_method parameter_name do
-            parameters[parameter_name]
-          end
-
-          define_singleton_method "#{parameter_name}=" do |value|
-            parameters[parameter_name] = value
-          end
-        end
-      end
-
-      module ClassMethods
-        def param(name, options = {})
-          self.parameters ||= []
-          self.parameters << {
-            name:      name,
-            required:  options.fetch(:required, true),
-            public:    options.fetch(:private, false),
-            type:      [*options[:type]].compact,
-            allow_nil: options.fetch(:allow_nil, false)
-          }
-        end
-      end
-    end
-  end
-end