steroids 1.0.0 → 1.6.0

data/lib/steroids/services/base.rb

@@ -0,0 +1,181 @@
+module Steroids
+  module Services
+    class Base < Steroids::Support::MagicClass
+      include Steroids::Support::ServicableMethods
+      include Steroids::Support::NoticableMethods
+
+      @@wrap_in_transaction = true
+      @@skip_callbacks = false
+
+      class AmbiguousProcessMethodError < Steroids::Errors::Base; end
+
+      class AsyncProcessArgumentError < Steroids::Errors::Base; end
+
+      class RuntimeError < Steroids::Errors::Base
+        self.default_message = "Runtime error"
+      end
+
+      # --------------------------------------------------------------------------------------------
+      # Core public interface
+      # --------------------------------------------------------------------------------------------
+
+      def call(*args, **options, &block)
+        return unless process_method.present?
+
+        @steroids_force = (!!options[:force]) || false
+        @steroids_skip_callbacks = (!!options[:skip_callbacks]) || @@skip_callbacks || false
+        if process_method.name == :async_process
+          schedule_process(*args, **options, &block)
+        else
+          exec_process(*args, **options, &block)
+        end
+      end
+
+      private
+
+      # --------------------------------------------------------------------------------------------
+      # Run process
+      # --------------------------------------------------------------------------------------------
+
+      def exec_process(*args, **options, &block)
+        outcome = process_wrapper do
+          run_before_callbacks(*args, **options) unless @steroids_skip_callbacks
+          process_method.call.tap do |outcome|
+            drop! if !block_given? && errors.any?
+            run_after_callbacks(outcome) unless @steroids_skip_callbacks
+          end
+        end
+      rescue StandardError => outcome
+        errors.add(outcome.message, outcome)
+        if respond_to?(:rescue!, true) || block_given?
+          Steroids::Logger.print(outcome)
+          send_apply(:rescue!, outcome)
+        else
+          raise outcome
+        end
+      ensure
+        ensure! if respond_to?(:ensure!, true)
+        block.apply(self, outcome, noticable: self.noticable) if block_given?
+      end
+
+      def schedule_process(*args, **options, &block)
+        async_exec = (!!options[:async]) || true
+        if self.respond_to?(:async_process, true)
+          if async_exec?(async_exec)
+            AsyncServiceJob.perform_later(
+              class_name: self.class.name,
+              params: @_steroids_serialized_init_options
+            )
+          else
+            exec_process(*args, **options, &block)
+          end
+        end
+      end
+
+      def process_method
+        self.class.validate_process_definition!
+        @process_method ||= (try_method(:process) || try_method(:async_process))
+      end
+
+      def async_exec?(async)
+        development_env = Rails.env.development? || Rails.env.test?
+        !!if async == true && (Sidekiq::ProcessSet.new.any? || !development_env)
+          !(development_env || Rails.const_defined?(:Console))
+        end
+      end
+
+      # --------------------------------------------------------------------------------------------
+      # Process wrapper
+      # --------------------------------------------------------------------------------------------
+
+      def process_wrapper(&block)
+        return block.call unless @@wrap_in_transaction
+
+        ActiveRecord::Base.transaction do
+          block.call
+        end
+      rescue RuntimeError => error
+        errors.add(error.message)
+      end
+
+      def run_before_callbacks(*args, **options)
+        if self.class.steroids_before_callbacks.is_a?(Array)
+          self.class.steroids_before_callbacks.each do |callback|
+            send_apply(callback, *args, **options)
+          end
+        end
+        send_apply(:before_process, *args, **options)
+      end
+
+      def run_after_callbacks(outcome)
+        send_apply(:after_process, outcome)
+        if self.class.steroids_after_callbacks.is_a?(Array)
+          self.class.steroids_after_callbacks.each do |callback|
+            send_apply(callback, outcome)
+          end
+        end
+      end
+
+      # --------------------------------------------------------------------------------------------
+      # Flow control
+      # --------------------------------------------------------------------------------------------
+
+      def drop!(message_or_nil = nil, message: nil)
+        unless @steroids_force
+          raise RuntimeError.new(
+            message: message_or_nil || message,
+            errors: errors,
+            log: true
+          )
+        end
+      end
+
+      class << self
+        def async?
+          self.private_instance_methods.include?(:async_process) || self.instance_methods.include?(:async_process)
+        end
+
+        def call(*args, **options, &block)
+          new(*args, **options).call(&block)
+        end
+
+        def new(*arguments, **options)
+          validate_process_definition!
+          instance = super
+          if self.async?
+            if arguments.empty? && options.serializable?
+              instance.instance_variable_set(:"@_steroids_serialized_init_options", options.deep_serialize)
+            else
+              raise AsyncProcessArgumentError.new("Async services require serializable options")
+            end
+          end
+          instance
+        end
+
+        def steroids_before_callbacks
+          @steroids_before_callbacks ||= []
+        end
+
+        def steroids_after_callbacks
+          @steroids_after_callbacks ||= []
+        end
+
+        def validate_process_definition!
+          if async? && (self.private_instance_methods.include?(:process) || self.instance_methods.include?(:process))
+            raise AmbiguousProcessMethodError.new("Can't define both `process` and `async_process`")
+          end
+        end
+
+        protected
+
+        def before_process(method)
+          steroids_before_callbacks << method
+        end
+
+        def after_process(method)
+          steroids_after_callbacks << method
+        end
+      end
+    end
+  end
+end

data/lib/steroids/support/magic_class.rb

@@ -0,0 +1,17 @@
+module Steroids
+  module Support
+    class MagicClass
+      include Steroids::Support::NoticableMethods
+
+      class << self
+        # TODO: Get rid of this.
+        # def inherited(subclass)
+        #   instance_variables.each do |var|
+        #     subclass_variable_value = instance_variable_get(var).dup
+        #     subclass.instance_variable_set(var, subclass_variable_value)
+        #   end
+        # end
+      end
+    end
+  end
+end

data/lib/steroids/support/noticable_methods.rb

@@ -0,0 +1,134 @@
+module Steroids
+  module Support
+    module NoticableMethods
+      extend ActiveSupport::Concern
+      # TODO:
+      # do |service, error:,full_notice:| etc
+      # error_methods: full_notice success_notice, etc
+      # Service: auto log notice
+      # error_mothods -> noticable
+      # noticable.logger / noticable.log
+      # noticable.erros (i.e. delagate error to noticable Noticable.new(self))
+
+      # --------------------------------------------------------------------------------------------
+      # TODO
+      # To rename collection for notices -> notice -> single message
+      # Message alias notice
+      # notice can be either error (full message) or success_notice
+
+      # --------------------------------------------------------------------------------------------
+      # Noticable collection
+      # --------------------------------------------------------------------------------------------
+
+      class NoticableCollection
+        NOTICABLE_TYPES = %i[errors notices]
+
+        attr_reader :collection
+
+        delegate :any?, :map, :each, :to_a, to: :collection
+
+        def initialize(collection_type)
+          @collection_type = NOTICABLE_TYPES.cast(collection_type)
+          @collection = []
+        end
+
+        def add(message, exception = nil)
+          nil.tap do
+            @collection << {
+              message: message.typed!(String),
+              exception: exception
+            }
+          end
+        end
+
+        def merge(errors)
+          nil.tap do
+            errors.each do |error|
+              @collection << error
+            end
+          end
+        end
+
+        alias_method :<<, :add
+
+        def full_messages
+          if @collection.any?
+            @collection.map do |error|
+              error[:message]
+            end.join("\n").presence
+          end
+        end
+      end
+
+      # --------------------------------------------------------------------------------------------
+      # Noticable runtime class (attached to instance)
+      # --------------------------------------------------------------------------------------------
+
+      class NoticableRuntime
+        attr_reader :notices
+        attr_reader :errors
+
+        def initialize(concern = [], success_notice: nil)
+          @concern = concern
+          @success_notice = success_notice.presence || success_notice_placeholder
+          @errors = NoticableCollection.new(:errors)
+          @notices = NoticableCollection.new(:notices)
+        end
+
+        def full_messages
+          if self.errors?
+            @errors.full_messages
+          else
+            @notices.full_messages.presence || @success_notice
+          end
+        end
+
+        alias_method :notice, :full_messages
+        alias_method :message, :full_messages
+
+        def errors?
+          @errors.any?
+        end
+
+        def success?
+          !errors?
+        end
+
+        def merge(noticable)
+          @notices.merge(noticable.notices)
+          @errors.merge(noticable.errors)
+        end
+
+        private
+
+        def success_notice_placeholder
+          humanized_class_name = @concern.class.name.split("::").last.underscore.humanize
+          "#{humanized_class_name} succeeded"
+        end
+      end
+
+      # --------------------------------------------------------------------------------------------
+      # Instance methods
+      # --------------------------------------------------------------------------------------------
+
+      included do
+        def noticable
+          @steroids_noticable_runtime ||= NoticableRuntime.new(
+            self,
+            success_notice: self.class.steroids_noticable_notice
+          )
+        end
+
+        delegate :notice, :errors, :notices, :success?, :errors?, to: :noticable
+      end
+
+      class_methods do
+        attr_reader :steroids_noticable_notice
+
+        def success_notice(message)
+          @steroids_noticable_notice ||= message
+        end
+      end
+    end
+  end
+end

data/lib/steroids/support/servicable_methods.rb

@@ -0,0 +1,34 @@
+module Steroids
+  module Support
+    module ServicableMethods
+      extend ActiveSupport::Concern
+
+      included do
+        def noticable_binding
+          Proc.new do |concern|
+            if self.respond_to?(:noticable) && concern.respond_to?(:noticable)
+              self.noticable.merge(concern.noticable)
+            end
+          end
+        end
+
+        def service_context_for(options)
+          respond_to?(:context) ? context.merge(options).symbolize_keys : options
+        end
+      end
+
+      class_methods do
+        def service(service_name, class_name:, **class_options)
+          define_method service_name do | *args, **options, &block |
+            service_options = service_context_for({ **class_options, **options })
+            service_block = block.present? ? block : noticable_binding
+            Object.const_get(class_name).new(
+              *args,
+              **service_options
+            ).call(**options, &service_block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/{base/type.rb → steroids/types/base.rb}

@@ -1,6 +1,6 @@
 module Steroids
-  module Base
-    class Type < Steroids::Base::Model
+  module Types
+    class Base < Steroids::Types::SerializableType
       def import(_options, _object = {})
         raise Steroids::Errors::InternalServerError.new(
           message: name + ': Import not implemented'
@@ -65,7 +65,7 @@ module Steroids
           instance
         rescue Exception => e
           raise Steroids::Errors::InternalServerError.new(
-            exception: e,
+            cause: e,
             message: 'Import failed'
           )
         end

data/lib/{base/model.rb → steroids/types/serializable_type.rb}

@@ -1,6 +1,6 @@
 module Steroids
-  module Base
-    class Model < Steroids::Base::Class
+  module Types
+    class SerializableType < Steroids::Support::MagicClass
       include ActiveModel::Model
       include ActiveModel::Serialization
 

data/lib/steroids/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Steroids
+  VERSION = "1.6.0".freeze
+end

data/lib/steroids.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require "steroids/railtie"
+require "steroids/engine"
+
+module Steroids
+  def self.loader
+    @loader ||= Loader.new
+  end
+
+  loader.zeitwerk.setup
+  loader.load_extensions!
+end

metadata

@@ -1,46 +1,87 @@
 --- !ruby/object:Gem::Specification
 name: steroids
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Paul Reboh
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-20 00:00:00.000000000 Z
-dependencies: []
-description: Steroids provides helper for Service-oriented, API based, Rails apps.
-email: dev@bernstein.io
+date: 2025-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7'
+description: Steroids - Rails helpers
+email: paul@reboh.net
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/base/class.rb
-- lib/base/error.rb
-- lib/base/hash.rb
-- lib/base/list.rb
-- lib/base/model.rb
-- lib/base/service.rb
-- lib/base/type.rb
-- lib/concern.rb
-- lib/concerns/controller.rb
-- lib/concerns/error.rb
-- lib/concerns/model.rb
-- lib/concerns/serializer.rb
-- lib/errors/bad_request_error.rb
-- lib/errors/conflict_error.rb
-- lib/errors/forbidden_error.rb
-- lib/errors/generic_error.rb
-- lib/errors/internal_server_error.rb
-- lib/errors/not_found_error.rb
-- lib/errors/not_implemented_error.rb
-- lib/errors/unauthorized_error.rb
-- lib/errors/unprocessable_entity_error.rb
-homepage: https://github.com/bernstein-io/steroids
-licenses: []
-metadata: {}
-post_install_message: 
+- README.md
+- Rakefile
+- app/jobs/steroids/async_service_job.rb
+- app/serializers/steroids/error_serializer.rb
+- lib/resources/quotes.yml
+- lib/steroids.rb
+- lib/steroids/controllers/methods.rb
+- lib/steroids/controllers/responders_helper.rb
+- lib/steroids/controllers/serializers_helper.rb
+- lib/steroids/engine.rb
+- lib/steroids/errors.rb
+- lib/steroids/errors/base.rb
+- lib/steroids/errors/context.rb
+- lib/steroids/errors/quotes.rb
+- lib/steroids/extensions/array_extension.rb
+- lib/steroids/extensions/class_extension.rb
+- lib/steroids/extensions/hash_extension.rb
+- lib/steroids/extensions/method_extension.rb
+- lib/steroids/extensions/module_extension.rb
+- lib/steroids/extensions/object_extension.rb
+- lib/steroids/extensions/proc_extension.rb
+- lib/steroids/logger.rb
+- lib/steroids/railtie.rb
+- lib/steroids/serializers/base.rb
+- lib/steroids/serializers/methods.rb
+- lib/steroids/services/base.rb
+- lib/steroids/support/magic_class.rb
+- lib/steroids/support/noticable_methods.rb
+- lib/steroids/support/servicable_methods.rb
+- lib/steroids/types/base.rb
+- lib/steroids/types/serializable_type.rb
+- lib/steroids/version.rb
+homepage: https://github.com/somelibs/steroids
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -48,15 +89,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.3.26
+signing_key:
 specification_version: 4
 summary: Steroids - Rails helpers
 test_files: []

data/lib/base/class.rb

@@ -1,15 +0,0 @@
-module Steroids
-  module Base
-    class Class
-      include Steroids::Concerns::Error
-      class << self
-        def inherited(subclass)
-          instance_variables.each do |var|
-            subclass_variable_value = instance_variable_get(var).dup
-            subclass.instance_variable_set(var, subclass_variable_value)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/base/error.rb

@@ -1,87 +0,0 @@
-module Steroids
-  module Base
-    class Error < StandardError
-      include ActiveModel::Serialization
-
-      @@DEFAULT_MESSAGE = 'An error has occurred while processing your request [Steroids::Base::Error]'
-
-      attr_reader :id
-      attr_reader :code
-      attr_reader :status
-      attr_reader :message
-      attr_reader :reference
-      attr_reader :data
-      attr_reader :errors
-      attr_reader :key
-      attr_reader :proverb
-      attr_reader :klass
-
-      def initialize(status: false, message:, key: nil, errors: nil, data: nil, reference: nil, exception: nil)
-        @id = SecureRandom.uuid
-        @key = assert_key(key)
-        @data = assert_data(data)
-        @code = assert_code(status)
-        @status = assert_status(status)
-        @reference = assert_reference(reference)
-        @message = assert_message(exception, message)
-        @errors = assert_errors(exception, errors)
-        @klass = assert_class(exception)
-        @proverb = proverb
-        super(@message)
-      end
-
-      protected
-
-      def proverb
-        begin
-          proverbs = Rails.cache.fetch('core/error_proverbs', expires_in: 1.hour) do
-            YAML.load_file(Rails.root.join('config/proverbs.yml'))
-          end
-        rescue StandardError => e
-          Utilities::Logger.push(e)
-          proverbs = ['One little bug...']
-        end
-        proverbs.sample
-      end
-
-      private
-
-      def assert_class(exception)
-        exception&.class
-      end
-
-      def assert_status(status)
-        status ? Rack::Utils.status_code(status) : false
-      end
-
-      def assert_code(status)
-        status ? status.to_s : 'error'
-      end
-
-      def assert_data(data)
-        data
-      end
-
-      def assert_reference(reference)
-        reference ? reference.to_s : 'http_error'
-      end
-
-      def assert_key(key)
-        Array(key)
-      end
-
-      def assert_errors(exception, errors = [])
-        exception_errors = Array(reflect_on_exception(exception, :message))
-        (Array(errors) + exception_errors).compact
-      end
-
-      def assert_message(exception, message)
-        message && message.to_s || @@DEFAULT_MESSAGE
-      end
-
-      def reflect_on_exception(exception, attribute)
-        exception&.respond_to?(attribute) ? exception.message : nil
-      end
-    end
-  end
-end