steroids 1.0.0 → 1.6.0

data/lib/base/hash.rb

@@ -1,49 +0,0 @@
-module Steroids
-  module Base
-    class Hash < Steroids::Base::Class
-      #include Enumerable # should implement each
-
-      attr_accessor :context
-
-      def initialize
-        @context = {}
-      end
-
-      def add(object = {})
-        @context.merge!(object)
-      end
-
-      def <<(object)
-        @context.merge!(object)
-      end
-
-      def to_json(*_args)
-        @context.to_json
-      end
-
-      def to_hash
-        @context.to_hash
-      end
-
-      def merge(object)
-        @context.merge(object)
-      end
-
-      def merge!(object)
-        @context.merge!(object)
-      end
-
-      def include?(key)
-        @context.include?(key)
-      end
-
-      def empty?
-        @context.empty?
-      end
-
-      def [](key)
-        @context[key]
-      end
-    end
-  end
-end

data/lib/base/list.rb

@@ -1,51 +0,0 @@
-module Steroids
-  module Base
-    class List < Steroids::Base::Class
-      #include Enumerable # should implement each
-
-      attr_accessor :errors
-
-      def initialize
-        @errors = []
-      end
-
-      def add(object = [])
-        add_error(object)
-      end
-
-      def <<(object = [])
-        add_error(object)
-      end
-
-      def to_ary
-        @errors
-      end
-
-      def to_a
-        to_ary
-      end
-
-      def any?
-        @errors.any?
-      end
-
-      def empty?
-        @errors.empty?
-      end
-
-      private
-
-      def add_error(object = [])
-        if object.is_a? ActiveModel::Errors
-          formatted = object.to_a.map { |item| item.gsub(/"/, '\'') }
-        elsif object.is_a?(Array)
-          formatted = object
-        elsif object.is_a?(String)
-          formatted = [object]
-        end
-        formatted.each { |item| Utilities::Logger.push(item) }
-        @errors.concat(formatted)
-      end
-    end
-  end
-end

data/lib/base/service.rb

@@ -1,104 +0,0 @@
-module Steroids
-  module Base
-    class Service < Steroids::Base::Class
-      include Steroids::Concerns::Error
-
-      @@wrap_in_transaction = true
-      @@skip_callbacks = false
-
-      def call(options = {})
-        @output = nil
-        @force = options[:force] ||= false
-        @skip_callbacks = options[:skip_callbacks] || @@skip_callbacks ||= false
-        @@wrap_in_transaction ? ActiveRecord::Base.transaction { process_service } : process_service
-        ensure!
-        @output
-      rescue StandardError => e
-        ActiveRecord::Rollback
-        ensure!
-        rescue_output = rescue!(e)
-        raise e unless rescue_output
-
-        Utilities::Logger.push(e)
-        rescue_output
-      end
-
-      protected
-
-      def process
-        true
-      end
-
-      def ensure!
-        true
-      end
-
-      def rescue!(_exception)
-        false
-      end
-
-      private
-
-      def process_service
-        run_before_callbacks unless @skip_callbacks
-        @output = process
-        run_after_callbacks unless @skip_callbacks
-        if errors? && !@force
-          raise Steroids::Errors::GenericError.new(
-            message: 'Oops, something went wrong',
-            errors: errors
-          )
-        end
-      end
-
-      def exit(message: nil)
-        unless @force
-          raise Steroids::Errors::InternalServerError.new(
-            message: message,
-            errors: errors
-          )
-        end
-      end
-
-      def drop(message: nil)
-        unless @force
-          raise Steroids::Errors::BadRequestError.new(
-            message: message,
-            errors: errors
-          )
-        end
-      end
-
-      def run_before_callbacks
-        if self.class.before_callbacks.is_a?(Array)
-          self.class.before_callbacks.each do |callback|
-            send(callback)
-          end
-        end
-      end
-
-      def run_after_callbacks
-        if self.class.after_callbacks.is_a?(Array)
-          self.class.after_callbacks.each do |callback|
-            send(callback)
-          end
-        end
-      end
-
-      class << self
-        attr_accessor :before_callbacks
-        attr_accessor :after_callbacks
-
-        def before_process(method)
-          @before_callbacks ||= []
-          @before_callbacks << method
-        end
-
-        def after_process(method)
-          @after_callbacks ||= []
-          @after_callbacks << method
-        end
-      end
-    end
-  end
-end

data/lib/concern.rb

@@ -1,130 +0,0 @@
-module Steroids
-  module Concern
-    # ----------------------------------------------------------------------- #
-    #                      Multiple Included Blocks Error                     #
-    # ----------------------------------------------------------------------- #
-
-    class MultipleIncludedBlocks < StandardError #:nodoc:
-      def initialize
-        super "Cannot define multiple 'included' blocks for a Concern"
-      end
-    end
-
-    # ----------------------------------------------------------------------- #
-    #                                  Extended                               #
-    # ----------------------------------------------------------------------- #
-
-    def self.extended(base)
-      base.instance_variable_set(:@_dependencies, [])
-    end
-
-    # ----------------------------------------------------------------------- #
-    #                            Concern: Append features                     #
-    # ----------------------------------------------------------------------- #
-
-    def get_proxy(base_class, instance, scope)
-      _self = self
-      proxy_name = "#{base_class.name.gsub('::', '') + SecureRandom.hex + @scope.to_s.classify}Proxy"
-      unless _self.const_defined?(proxy_name)
-        proxy_class = Class.new base_class do
-          self.table_name = base_class.table_name
-
-          define_method :initialize do |instance|
-            super(instance.attributes)
-          end
-
-          instance.attributes.each do |key, _attribute|
-            define_method key do
-              instance.read_attribute(key)
-            end
-
-            define_method "#{key}=" do |value|
-              instance.write_attribute(key, value)
-            end
-          end
-
-          native_methods = Class.instance_methods
-          active_methods = ActiveRecord::Base.instance_methods
-          own_methods = instance_methods - base_class.instance_methods
-
-          instance_methods.each do |method|
-            next unless !native_methods.include?(method) && !own_methods.include?(method) &&
-                        !active_methods.include?(method) && method != scope
-
-            define_method method do |*args|
-              instance.send(method, *args)
-            end
-          end
-        end
-        _self.const_set(proxy_name, proxy_class)
-      end
-      _self.const_get(proxy_name)
-    end
-
-    def append_features(base_class)
-      _self = self
-      if base_class.instance_variable_defined?(:@_dependencies)
-        base_class.instance_variable_get(:@_dependencies) << self
-        false
-      else
-        _scope_name = @_scope_name
-        _dependencies = @_dependencies
-        _included_block = @_included_block
-
-        # ----------------------------------------------------------------------- #
-        #                        Ruby native concern handlers                     #
-        # ----------------------------------------------------------------------- #
-
-        return false if base_class < self
-
-        super
-
-        # ----------------------------------------------------------------------- #
-        #                 Defining the concern scope as a method                  #
-        # ----------------------------------------------------------------------- #
-
-        define_method @_scope_name do
-          instance = self
-
-          proxy = _self.get_proxy(base_class, instance, _scope_name)
-
-          # ----------------------------------------------------------------------- #
-          #                          Proc & Dependency injection                    #
-          # ----------------------------------------------------------------------- #
-
-          _dependencies.each { |dependency| proxy.include(dependency) }
-          if _self.const_defined?(:ClassMethods)
-            proxy.extend const_get(:ClassMethods)
-          end
-          if _self.instance_variable_defined?(:@_included_block)
-            proxy.class_eval(&_included_block)
-          end
-
-          # ----------------------------------------------------------------------- #
-          #                     Rails & Ruby native concern handlers                #
-          # ----------------------------------------------------------------------- #
-
-          @proxy ||= proxy.new(instance)
-        end
-      end
-    end
-
-    def concern(scope, &block)
-      if instance_variable_defined?(:@_included_block)
-        if @_included_block.source_location != block.source_location
-          raise MultipleIncludedBlocks
-        end
-      else
-        @_scope_name = scope
-        @_included_block = block
-      end
-    end
-
-    def class_methods(&class_methods_module_definition)
-      mod = const_defined?(:ClassMethods, false) ?
-        const_get(:ClassMethods) :
-        const_set(:ClassMethods, Module.new)
-      mod.module_eval(&class_methods_module_definition)
-    end
-  end
-end

data/lib/concerns/error.rb

@@ -1,20 +0,0 @@
-module Steroids
-  module Concerns
-    module Error
-      extend ActiveSupport::Concern
-      included do
-        def errors?
-          errors.any?
-        end
-
-        def errors
-          @errors ||= Steroids::Base::List.new
-        end
-
-        class << self
-          attr_accessor :errors
-        end
-      end
-    end
-  end
-end

data/lib/concerns/model.rb

@@ -1,9 +0,0 @@
-module Steroids
-  module Concerns
-    module Model
-      extend ActiveSupport::Concern
-      included do
-      end
-    end
-  end
-end

data/lib/errors/bad_request_error.rb

@@ -1,15 +0,0 @@
-module Steroids
-  module Errors
-    class BadRequestError < Steroids::Base::Error
-      def initialize(options = {})
-        options[:message] ||= 'Something went wrong (Bad request)'
-        super(
-          {
-            status: :bad_request,
-            key: :bad_request
-          }.merge(options)
-        )
-      end
-    end
-  end
-end

data/lib/errors/conflict_error.rb

@@ -1,15 +0,0 @@
-module Steroids
-  module Errors
-    class ConflictError < Steroids::Base::Error
-      def initialize(options = {})
-        options[:message] ||= "Something went wrong (Internal conflict)"
-        super(
-          {
-            status: :conflict,
-            key: :conflict
-          }.merge(options)
-        )
-      end
-    end
-  end
-end

data/lib/errors/forbidden_error.rb

@@ -1,15 +0,0 @@
-module Steroids
-  module Errors
-    class ForbiddenError < Steroids::Base::Error
-      def initialize(options = {})
-        options[:message] ||= "Your request was denied (Forbidden)"
-        super(
-          {
-            status: :forbidden,
-            key: :forbidden
-          }.merge(options)
-        )
-      end
-    end
-  end
-end

data/lib/errors/generic_error.rb

@@ -1,14 +0,0 @@
-module Steroids
-  module Errors
-    class GenericError < Steroids::Base::Error
-      def initialize(options = {})
-        super(
-          {
-            message: options[:message] || "Something went wrong (Generic error)",
-            status: options[:status] ? Rack::Utils.status_code(status) : false
-          }.merge(options)
-        )
-      end
-    end
-  end
-end

data/lib/errors/internal_server_error.rb

@@ -1,15 +0,0 @@
-module Steroids
-  module Errors
-    class InternalServerError < Steroids::Base::Error
-      def initialize(options = {})
-        options[:message] ||= "Something went wrong (Internal error)"
-        super(
-          {
-            status: :internal_server_error,
-            key: :server_error
-          }.merge(options)
-        )
-      end
-    end
-  end
-end

data/lib/errors/not_found_error.rb

@@ -1,15 +0,0 @@
-module Steroids
-  module Errors
-    class NotFoundError < Steroids::Base::Error
-      def initialize(options = {})
-        super(
-          {
-            message: options[:message] || "We couldn't find what you were looking for",
-            status: :not_found,
-            key: :not_found
-          }.merge(options)
-        )
-      end
-    end
-  end
-end

data/lib/errors/not_implemented_error.rb

@@ -1,15 +0,0 @@
-module Steroids
-  module Errors
-    class NotImplementedError < Steroids::Base::Error
-      def initialize(options = {})
-        options[:message] ||= "This feature hasn't been implemented yet"
-        super(
-          {
-            status: :not_implemented,
-            key: :not_implemented
-          }.merge(options)
-        )
-      end
-    end
-  end
-end

data/lib/errors/unauthorized_error.rb

@@ -1,15 +0,0 @@
-module Steroids
-  module Errors
-    class UnauthorizedError < Steroids::Base::Error
-      def initialize(options = {})
-        options[:message] ||= 'You shall not pass! (Unauthorized)'
-        super(
-          {
-            status: :unauthorized,
-            key: :unauthorized
-          }.merge(options)
-        )
-      end
-    end
-  end
-end

data/lib/errors/unprocessable_entity_error.rb

@@ -1,15 +0,0 @@
-module Steroids
-  module Errors
-    class UnprocessableEntityError < Steroids::Base::Error
-      def initialize(options = {})
-        options[:message] ||= "We couldn't understand your request (Unprocessable entity)"
-        super(
-          {
-            status: :unprocessable_entity,
-            key: :unprocessable_entity
-          }.merge(options)
-        )
-      end
-    end
-  end
-end