steroids 1.0.0 → 1.6.0

data/lib/steroids/extensions/class_extension.rb

@@ -0,0 +1,141 @@
+module Steroids
+  module Extensions
+    module ClassExtension
+      # --------------------------------------------------------------------------------------------
+      # Methods
+      # --------------------------------------------------------------------------------------------
+
+      def runtime_methods(include_modules = true)
+        methods = if include_modules
+          self.methods(true)
+        else
+          methods = []
+          klass = self.class
+          while klass
+            methods += klass.methods
+            klass = klass.superclass
+          end
+          methods
+        end
+
+        methods - Object.methods
+      end
+
+      def runtime_instance_methods(include_modules = true)
+        methods = if include_modules
+          self.instance_methods(true)
+        else
+          methods = []
+          klass = self.class
+          while klass
+            methods += klass.methods
+            klass = klass.superclass
+          end
+          methods
+        end
+
+        methods - Object.instance_methods
+      end
+
+      # --------------------------------------------------------------------------------------------
+      # Delegate, proxy and so on
+      # --------------------------------------------------------------------------------------------
+
+      def delegate_alias(alias_name, to:, method:)
+        define_method(alias_name) do |*arguments, **options, &block|
+          delegate = send(to)
+          delegate.send_apply(method, *arguments, **options, &block)
+        end
+      end
+
+      def forward_methods_to(method_name, **options)
+        respond_to_hander = options.fetch(:if)
+        return unless self.instance_methods.include?(method_name) && respond_to_hander.present?
+
+        define_method(:method_missing) do |missing_method_name, *arguments, **options, &block|
+          if self.send_apply(respond_to_hander, missing_method_name)
+            self.send_apply(method_name, missing_method_name)
+          else
+            super(missing_method_name, *arguments, **options, &block)
+          end
+        end
+      end
+
+      def try_delegate(*method_names, **options)
+        # condition = options.fetch(:if, nil)
+        delegate_name = options.fetch(:to)
+        method_names.each do |method_name|
+          self.define_method(method_name) do |*arguments, **options, &block|
+            delegate_object = self.try(delegate_name) rescue false
+            if delegate_object.present? && delegate_object.try_method(method_name)
+              delegate_object.send_apply(method_name, *arguments, **options, &block)
+            else
+              super(*arguments, **options, &block)
+            end
+          end
+        end
+      end
+
+      # --------------------------------------------------------------------------------------------
+      # Naming
+      # --------------------------------------------------------------------------------------------
+
+      def own_klass_name
+        self.name.split('::').last
+      end
+
+      # --------------------------------------------------------------------------------------------
+      # Anonymous class building
+      # --------------------------------------------------------------------------------------------
+
+      def proxy(instance, &block)
+        name = "#{instance.class.name}Proxy"
+        Class.build_anonymous(name) do
+          include Module.new(&block)
+
+          define_method(:klass) do
+            instance.class
+          end
+
+          define_method(:method_missing) do |missing_method_name, *arguments, **options, &block|
+            if instance.respond_to?(missing_method_name, true)
+              instance.send_apply(missing_method_name, *arguments, **options, &block)
+            else
+              super(missing_method_name, *arguments, **options, &block)
+            end
+          end
+
+          define_method(:respond_to_missing?) do |missing_method_name, *arguments, **options, &block|
+            !!instance.respond_to?(missing_method_name, true)
+          end
+        end.new
+      end
+
+      def build_anonymous(name, **options, &block)
+        parent_class = options.fetch(:inherit, nil) || Class.new
+        class_name = name.camelize
+        self.new(parent_class) do
+          include Module.new(&block)
+
+          define_singleton_method(:name) do
+            class_name
+          end
+
+          define_singleton_method(:inspect) do
+            super().gsub("#<Class:", "#<Anonymous:#{class_name}:")
+          end
+
+          define_singleton_method(:to_s) do
+            self.inspect
+          end
+
+          define_singleton_method(:anonymous?) do
+            true
+          end
+        end
+      end
+    end
+  end
+end
+
+Class.include(Steroids::Extensions::ClassExtension)

data/lib/steroids/extensions/hash_extension.rb

@@ -0,0 +1,14 @@
+module Steroids
+  module Extensions
+    module HashExtension
+      def fetch_any(*values)
+        matching_key = self.keys.find do |key|
+          !!values.include?(key)
+        end
+        self[matching_key]
+      end
+    end
+  end
+end
+
+Hash.include(Steroids::Extensions::HashExtension)

data/lib/steroids/extensions/method_extension.rb

@@ -0,0 +1,63 @@
+module Steroids
+  module Extensions
+    module MethodExtension
+      # --------------------------------------------------------------------------------------------
+      # Calling
+      # --------------------------------------------------------------------------------------------
+
+      # TODO: Use *arguments.extract_options instead!
+      def apply(*given_arguments, **given_options, &block)
+        applied_arguments = dynamic_arguments_for(given_arguments, given_options)
+        applied_options = dynamic_options_for(given_options)
+        self.yield(*applied_arguments, **applied_options, &block)
+      end
+
+      def dynamic_arguments_for(given_arguments, given_options)
+        return given_arguments if self.rest?
+
+        expected_arguments_count = self.least_arguments.count
+        non_nil_arguments_count = given_arguments.take_while(&:present?).count
+        applied_arguments = given_arguments.first([expected_arguments_count, non_nil_arguments_count].min)
+        return applied_arguments if self.spread? && self.options.any?
+
+        applied_arguments << given_options if applied_arguments.count < self.arguments.count
+        applied_arguments
+      end
+
+      def dynamic_options_for(given_options)
+        return given_options if self.spread?
+
+        given_options.select { |key| self.options.include?(key) }
+      end
+
+      private def least_arguments
+        all_arguments = self.parameters.select { |key,v| key == :req || key == :opt }
+        required_arguments = all_arguments.reverse.take_while { |element| element.first == :opt }
+        required_count = arguments.size - required_arguments.size
+        arguments.first(required_count)
+      end
+
+      # --------------------------------------------------------------------------------------------
+      # Parameters
+      # --------------------------------------------------------------------------------------------
+
+      def arguments
+        self.parameters.select { |key,v| key == :req || key == :opt }.map { |argument| argument.second }
+      end
+
+      def options
+        self.parameters.select { |key,v| key == :key || key == :keyreq }.map { |option| option.second }
+      end
+
+      def spread?
+        !!self.parameters.find { |parameter| parameter.first == :keyrest }
+      end
+
+      def rest?
+        !!self.parameters.find { |parameter| parameter.first == :rest }
+      end
+    end
+  end
+end
+
+Method.include(Steroids::Extensions::MethodExtension)

data/lib/steroids/extensions/module_extension.rb

@@ -0,0 +1,32 @@
+module Steroids
+  module Extensions
+    module ModuleExtension
+      def grundclass
+        self.singleton_class? ? ObjectSpace.each_object(self).to_a.last : self
+      end
+
+      private
+
+      def mixin(method_name)
+        if grundclass.methods.include?(method_name)
+          grundclass.define_method(method_name) do |*args|
+            self.class.send(method_name, *args)
+          end
+        else
+          raise ArgumentError.new("Mixin expects a class method")
+        end
+      end
+
+      def mixin_alias(alias_name, method_name)
+        grundclass.define_method(alias_name) do |*args|
+          self.class.send(method_name, *args)
+        end
+        grundclass.define_singleton_method(alias_name) do |*args|
+          self.send(method_name, *args)
+        end
+      end
+    end
+  end
+end
+
+Module.include(Steroids::Extensions::ModuleExtension)

data/lib/steroids/extensions/object_extension.rb

@@ -0,0 +1,122 @@
+module Steroids
+  module Extensions
+    module ObjectExtension
+      # --------------------------------------------------------------------------------------------
+      # Apply and send
+      # --------------------------------------------------------------------------------------------
+
+      def instance_apply(*given_arguments, **given_options, &block)
+        applied_arguments = dynamic_arguments_for(block, given_arguments)
+        applied_options = dynamic_options_for(block, given_options)
+        self.instance_exec(*applied_arguments, **applied_options, &block)
+      end
+
+      # TODO: Rename to try_apply and implement/alias try_send
+      def send_apply(method_name, *given_arguments, **given_options, &block)
+        return unless respond_to?(method_name, true)
+        method = method(method_name)
+        applied_arguments = method.dynamic_arguments_for(given_arguments, given_options)
+        applied_options = method.dynamic_options_for(given_options)
+        self.send(method_name, *applied_arguments, **applied_options, &block)
+      end
+
+      # TODO: Rename to send_apply
+      def send_apply!(method_name, *given_arguments, **given_options, &block)
+        return NoMethodError.new("Send apply", method_name) unless self.respond_to?(method_name, true)
+
+        send_apply(method_name, *given_arguments, **given_options, &block)
+      end
+
+      # --------------------------------------------------------------------------------------------
+      # Marshall dump
+      # --------------------------------------------------------------------------------------------
+
+      def marshallable?
+        !!Marshal.dump(self)
+      rescue TypeError
+        false
+      end
+
+      # --------------------------------------------------------------------------------------------
+      # Try method
+      # --------------------------------------------------------------------------------------------
+
+      def try_method(method_name)
+        if self.respond_to?(method_name, true)
+          self.method(method_name)
+        end
+      end
+
+      # --------------------------------------------------------------------------------------------
+      # Type
+      # --------------------------------------------------------------------------------------------
+
+      def typed(expected_type)
+        return itself if instance_of?(expected_type) || itself == nil
+      end
+
+      def typed!(expected_type)
+        typed_itself = typed(expected_type)
+        return typed_itself if typed_itself == itself
+
+        message = "Expected #{self.inspect} to be an instance of #{expected_type.inspect}"
+        TypeError.new(message).tap do |exception|
+          exception.set_backtrace(caller)
+          raise exception
+        end
+      end
+
+      # --------------------------------------------------------------------------------------------
+      # If nil default
+      # --------------------------------------------------------------------------------------------
+
+      def ifnil(default)
+        itself == nil ? default : itself
+      end
+
+      # --------------------------------------------------------------------------------------------
+      # Serialization
+      # --------------------------------------------------------------------------------------------
+
+      def serializable?(include_object = true)
+        if self.is_a?(Hash)
+          self.all? do |key, value|
+            key.serializable?(include_object) && value.serializable?(include_object)
+          end
+        elsif self.is_a?(Array)
+          self.all? do |value|
+            value.serializable?(include_object)
+          end
+        elsif self.is_a?(String) || self.is_a?(Symbol) || self.is_a?(Numeric) ||
+          self.is_a?(TrueClass) || self.is_a?(FalseClass) || self.is_a?(NilClass)
+          true
+        elsif include_object == true
+          self.respond_to?(:as_json) && self.as_json.serializable?(include_object)
+        else
+          false
+        end
+      end
+
+      def deep_serialize(include_object = true)
+        raise TypeError, "Cannot serialize object of type #{self.class}" unless serializable?(include_object)
+
+        case self
+        when Hash
+          self.to_h.transform_values { |value| value.deep_serialize(include_object) }
+        when Array
+          self.map { |value| value.deep_serialize(include_object) }
+        when String, Symbol, Numeric, TrueClass, FalseClass, NilClass
+          self
+        else
+          if include_object && self.respond_to?(:to_h)
+            self.to_h.deep_serialize(include_object)
+          elsif include_object && self.respond_to?(:as_json)
+            self.as_json.deep_serialize(include_object)
+          end
+        end
+      end
+    end
+  end
+end
+
+Object.include(Steroids::Extensions::ObjectExtension)

data/lib/steroids/extensions/proc_extension.rb

@@ -0,0 +1,9 @@
+module Steroids
+  module Extensions
+    module ProcExtension
+      include Steroids::Extensions::MethodExtension
+    end
+  end
+end
+
+Proc.include(Steroids::Extensions::ProcExtension)

data/lib/steroids/logger.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+require 'rainbow'
+
+module Steroids
+  class Logger
+    @notifier = false
+
+    class << self
+      attr_accessor :notifier
+
+      def print(input = nil, verbosity: nil, format: :decorated)
+        assert_format(format)
+        assert_backtrace(input, verbosity)
+        if input.is_a?(Steroids::Errors::Base) && input.logged == true
+          false
+        else
+          level = assert_level(input)
+          output = format_input(level, input)
+          Rails.logger.send(level, output)
+          notify(level, output)
+          true
+        end
+      end
+
+      private
+
+      def assert_level(input)
+        return :info unless input.is_a?(Exception)
+
+        if input.is_a?(Steroids::Errors::InternalServerError) || input.is_a?(Steroids::Errors::GenericError)
+          :error
+        elsif input.is_a?(Steroids::Errors::Base)
+          :warn
+        else
+          :error
+        end
+      end
+
+      def assert_color(level)
+        case level
+        when :error
+          :red
+        when :warn
+          :yellow
+        when :info
+          :green
+        end
+      end
+
+      def assert_backtrace(input, verbosity)
+        @backtrace = input.is_a?(Exception) ? input.backtrace : caller
+        @backtrace_verbosity = begin
+          if [:full, :concise, :none].include?(verbosity)
+            verbosity
+          elsif input.is_a?(Exception)
+            :full
+          else
+            :none
+          end
+        end
+      end
+
+      def clean_path(input_path)
+        root_path_array = Rails.root.to_s.split("/")
+        root_path_array.slice!(root_path_array.size-1..)
+        input_path_array = input_path.split("/")
+        zipped_array = root_path_array.zip(input_path_array)
+        matchs = zipped_array.take_while { |root_path, input_path| root_path == input_path }
+        output_path = matchs.map(&:first)
+        common_path = output_path.join("/")
+        input_path.sub(common_path, '').sub(/^\//, '')
+      end
+
+      def assert_format(format)
+        @format = [:raw, :decorated].include?(format) ? format : :decorated
+      end
+
+      def notify(level, input)
+        if @notifier.respond_to?(:call) && input.is_a?(Exception) && [:error, :warn].include?(level)
+          @notifier.call(input)
+        end
+      end
+
+      def backtrace_origin
+        @backtrace.find do |line|
+          !line.include?(".bundle/gems/ruby") && !line.include?("steroids/lib/steroids")
+        end
+      end
+
+      def format_timestamp(input)
+        if input.respond_to?(:timestamp) && input.timestamp.is_a?(DateTime)
+          "(at #{input.timestamp.to_time.to_s})"
+        end
+      end
+
+      def format_message(input)
+        [
+          "\n#{Rainbow("▶").magenta} #{Rainbow(input.class.to_s).red} -- #{Rainbow(input.message.to_s.upcase_first).magenta}",
+          input.respond_to?(:id) && "[ID: #{input.id.to_s}]",
+          format_timestamp(input),
+        ].compact_blank.join(" ")
+      end
+
+      def format_origin
+        "  ↳ #{clean_path(backtrace_origin.to_s)}"
+      end
+
+      def format_cause(input)
+        cause_message = assert_attribute(input, :cause_message) || assert_attribute(input.cause, :message) || "Unknown error"
+        [
+          Rainbow("\n  ➤ Cause: #{input.cause.class.name}").cyan + " -- #{cause_message.to_s}",
+          input.cause.respond_to?(:record) && input.cause.record && "(#{input.cause.record.class.name})"
+        ].compact_blank.join(" ")
+      end
+
+      def format_backtrace(input)
+        if @backtrace_verbosity == :full
+          "  " + @backtrace.map do |path|
+            clean_path(path.to_s)
+          end.join("\n  ") if @backtrace.any?
+        elsif @backtrace_verbosity == :concise
+          format_origin
+        end
+      end
+
+      def format_errors(input)
+        "  • " + input.errors.map do |error|
+          error_class = input.try(:record) || input.is_a?(Exception) ? input.class.name : "Error"
+          "#{error_class}: #{error}"
+        end.join("\n  • ") if input.errors.any?
+      end
+
+      def format_context(input)
+        Rainbow("  ➤ Context: ").cyan + Rainbow(input.context.to_s).blue
+      end
+
+      def format_input(level, input)
+        color = assert_color(level)
+        if input.is_a?(Exception)
+          [
+            format_message(input),
+            assert_attribute(input, :errors) && format_errors(input),
+            assert_attribute(input, :context) && format_context(input),
+            [:full, :concise].include?(@backtrace_verbosity) && format_backtrace(input),
+            assert_attribute(input, :cause) && format_cause(input)
+          ].compact_blank.join("\n") + "\n"
+        else
+          decorator = "\n#{Rainbow("▶").magenta} #{Rainbow("Steroids::Logger").send(color)} -- #{Rainbow(level.to_s).send(color)}:"
+          [
+            @format == :decorated && decorator,
+            input,
+            [:full, :concise].include?(@backtrace_verbosity) && format_backtrace(input)
+          ].compact_blank.join("\n") + "\n"
+        end
+      end
+
+      def assert_attribute(instance, key)
+        instance.respond_to?(key) && instance.public_send(key)
+      end
+    end
+  end
+end

data/lib/steroids/railtie.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require "zeitwerk"
+require "rails"
+require "active_model_serializers"
+
+module Steroids
+  # ------------------------------------------------------------------------------------------------
+  # Custom loader (Zeitwerk)
+  # ------------------------------------------------------------------------------------------------
+  class Loader
+    def load_extensions!
+      core_extensions = File.expand_path("#{gem_path}/steroids/extensions/**/**/*.rb", __dir__)
+      extensions_dir = Dir.glob(core_extensions)
+      Dir.glob(extensions_dir).sort.each do |path|
+        require path
+      end
+    end
+
+    def file_update_checker(&loader)
+      watch_list = Dir["#{gem_path}/**/*.rb"]
+      @file_update_checker ||= ActiveSupport::FileUpdateChecker.new(watch_list, &loader)
+    end
+
+    def zeitwerk
+      @loader ||= Zeitwerk::Loader.new.tap do |loader|
+        loader.tag = "steroids"
+        loader.enable_reloading
+        loader.push_dir(gem_path)
+        loader.inflector = Zeitwerk::GemInflector.new("#{gem_path}/steroids.rb")
+      end
+    end
+
+    private
+
+    def gem_path
+      @gem_path ||= File.expand_path("..", __dir__)
+    end
+  end
+
+  # ------------------------------------------------------------------------------------------------
+  # Rails hooks (Railtie)
+  # ------------------------------------------------------------------------------------------------
+  class Railtie < ::Rails::Railtie
+    config.to_prepare do
+      loader = Steroids.loader
+      if loader.file_update_checker.updated?
+        loader.file_update_checker.execute
+        loader.zeitwerk.reload
+      end
+    end
+
+    initializer "steroids.add_reloader" do |app|
+      loader = Steroids.loader
+      app.reloaders << loader.file_update_checker do
+        loader.zeitwerk.reload
+        loader.load_extensions!
+      end
+    end
+  end
+end

data/lib/steroids/serializers/base.rb

@@ -0,0 +1,7 @@
+module Steroids
+  module Serializers
+    class Base < ActiveModel::Serializer
+      include Steroids::Serializers::Methods
+    end
+  end
+end

data/lib/{concerns/serializer.rb → steroids/serializers/methods.rb}

@@ -1,6 +1,6 @@
 module Steroids
-  module Concerns
-    module Serializer
+  module Serializers
+    module Methods
       extend ActiveSupport::Concern
       included do
         def initialize(object, options = {})
@@ -34,7 +34,7 @@ module Steroids
                 when /^[-+]?[1-9]([0-9]*)?$/
                   options[:params][key] = Integer(value)
               end
-            rescue => exception
+            rescue
             end
           end
           options