steroids 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0d3566aa564b722d7e942f934413dd202fe31fe79af63089f3f3d98f672aa1e2
+  data.tar.gz: da5c4c357a4de8c03b57b772c6d23282f04f530a1282729bd8cd8825f84171ce
+SHA512:
+  metadata.gz: ed66368c3eb9cc84314b6ff2a6e27a41a00f856003fdee7b2198f56442c57b6cacc4961f186830928f1637dc27543e47fd8c13867c37d3e085dd15de4a772c37
+  data.tar.gz: c2d8bdc5a6df81fed23da4ac0ad647458e6c2a99b91eea53a6c2c75fabcdd6452c8b028f93cd0db7ff15bf30aa663341f28c6b96fb187f17c220250ce9f96feb

data/lib/base/class.rb

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,87 @@
+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

data/lib/base/hash.rb

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,51 @@
+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/model.rb

@@ -0,0 +1,34 @@
+module Steroids
+  module Base
+    class Model < Steroids::Base::Class
+      include ActiveModel::Model
+      include ActiveModel::Serialization
+
+      def attributes
+        self.class.attributes || []
+      end
+
+      class << self
+        alias native_attr_accessor attr_accessor
+
+        def attr_accessor(*attr)
+          attributes(*attr)
+        end
+
+        def attributes(*attr)
+          @attributes ||= []
+          @attributes.concat(attr).uniq
+          native_attr_accessor(*attr)
+          @attributes
+        end
+
+        def attribute(attribute)
+          @attributes ||= []
+          @attributes << attribute unless @attributes.include?(attribute)
+          native_attr_accessor(attribute)
+          attr
+        end
+      end
+    end
+  end
+end

data/lib/base/service.rb

@@ -0,0 +1,104 @@
+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/base/type.rb

@@ -0,0 +1,102 @@
+module Steroids
+  module Base
+    class Type < Steroids::Base::Model
+      def import(_options, _object = {})
+        raise Steroids::Errors::InternalServerError.new(
+          message: name + ': Import not implemented'
+        )
+      end
+
+      def to_s
+        if attributes.present?
+          values.to_json
+        else
+          ''
+        end
+      end
+
+      def values
+        hash = {}
+        attributes.each do |attribute|
+          hash[attribute] = read_attribute_for_serialization(attribute)
+        end
+        hash
+      end
+
+      def validate
+        validate_required && super
+      end
+
+      def validate!
+        validate_required!
+        super
+      end
+
+      def validate_required
+        missing_attributes.empty?
+      end
+
+      def validate_required!
+        unless validate_required
+          raise Steroids::Errors::InternalServerError.new(
+            message: self.class.name + ': Missing required attributes ' + missing_attributes.to_s
+          )
+        end
+      end
+
+      def missing_attributes
+        self.class.missing_attributes_for(values)
+      end
+
+      class << self
+        def required_attributes
+          @required_attributes ||= []
+        end
+
+        def requires(attribute, _options = {})
+          unless required_attributes.include?(attribute)
+            required_attributes << attribute
+          end
+        end
+
+        def import(options, object)
+          instance = new({}, true)
+          instance.import(options, object) if options.present?
+          instance
+        rescue Exception => e
+          raise Steroids::Errors::InternalServerError.new(
+            exception: e,
+            message: 'Import failed'
+          )
+        end
+
+        def missing_attributes_for(payload)
+          missing_attributes = []
+          required_attributes.each do |attribute|
+            unless payload.keys.include?(attribute) && !payload[attribute].nil?
+              missing_attributes << attribute
+            end
+          end
+          missing_attributes
+        end
+
+        def validate_required(payload)
+          missing_attributes_for(payload).empty?
+        end
+
+        def validate_required!(payload)
+          unless validate_required(payload)
+            raise Steroids::Errors::InternalServerError.new(
+              message: name + ': Missing required attributes ' + missing_attributes_for(payload).to_s
+            )
+          end
+        end
+
+        def new(options = {}, ignore_required = false)
+          validate_required!(options) unless ignore_required
+          super(options)
+        end
+      end
+    end
+  end
+end

data/lib/concern.rb

@@ -0,0 +1,130 @@
+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/controller.rb

@@ -0,0 +1,73 @@
+module Steroids
+  module Concerns
+    module Controller
+      extend ActiveSupport::Concern
+      included do
+        before_action do
+          context.add(params: params)
+        end
+
+        protected
+
+        def respond_with(data, options = {})
+          options = __parse_options(data, options)
+          data = __apply_scopes(data, options)
+          data = __apply_pagination(data, options)
+          return __response(data, options)
+        end
+
+        def context
+          @context ||= Steroids::Base::Hash.new
+        end
+
+        private
+
+        def __parse_options(data, options)
+          options[:serializer] ||= self.class.serializer
+          options[:params] = params
+          if data.is_a?(Array) || data.is_a?(ActiveRecord::Relation)
+            options[:each_serializer] ||= options[:serializer]
+            options[:serializer] = ::CollectionSerializer
+          end
+          options
+        end
+
+        def __apply_scopes(data, options)
+          if data.is_a?(ActiveRecord::Relation)
+            data = apply_scopes(data)
+            if options[:scoped_only] == true && current_scopes.empty?
+              return []
+            end
+          end
+          data
+        end
+
+        def __apply_pagination(data, options)
+          if data.is_a?(ActiveRecord::Relation) && options[:paginate] == true
+            return data.page(params[:page] || 1)
+          end
+          data
+        end
+
+        def __response(data, options)
+          status = options[:status]
+          if data
+            options = options.merge({ json: data })
+            options = options.merge(@context)
+            render(options)
+          else
+            status ? head(status) : raise(Steroids::Errors::NotFoundError)
+          end
+        end
+
+        class << self
+          attr_accessor :serializer
+
+          def default_serializer(serializer)
+            @serializer = serializer
+          end
+        end
+      end
+    end
+  end
+end

data/lib/concerns/error.rb

@@ -0,0 +1,20 @@
+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

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

data/lib/concerns/serializer.rb

@@ -0,0 +1,70 @@
+module Steroids
+  module Concerns
+    module Serializer
+      extend ActiveSupport::Concern
+      included do
+        def initialize(object, options = {})
+          options.each { |name, value| instance_variable_set("@#{name}", value) }
+          super(object, options)
+        end
+
+        def serializable_hash(adapter_options = nil, options = {}, adapter_instance = self.class.serialization_adapter_instance)
+          if @object
+            hash = super
+            hash.each { |key, value| hash.delete(key) if value.nil? }
+            hash
+          end
+        end
+
+        def json_key
+          'root'
+        end
+
+        protected
+
+        def parse_options
+          options ||= @instance_options ||= {}
+          options[:params]&.each do |key, value|
+            begin
+              case options[:params][key]
+                when 'true'
+                  options[:params][key] = true
+                when 'false'
+                  options[:params][key] = false
+                when /^[-+]?[1-9]([0-9]*)?$/
+                  options[:params][key] = Integer(value)
+              end
+            rescue => exception
+            end
+          end
+          options
+        end
+
+        def options
+          options ||= parse_options
+        end
+
+        def render(data, options = {})
+          if options[:serializer]
+            klass = Object.const_get(options[:serializer])
+            klass.new(data, self.options.merge(options))
+          else
+            ActiveModel::Serializer.get_serializer_for(data.class.name)
+          end
+        end
+
+        class << self
+          # Awaiting PR: https://github.com/rails-api/active_model_serializers/pull/2145
+          # and https://github.com/rails-api/active_model_serializers/pull/2148
+          def attributes(*attrs, **options)
+            options = options.except(:key)
+            attrs = attrs.first if attrs.first.class == Array
+            attrs.each do |attr|
+              attribute(attr, options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/errors/bad_request_error.rb

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,15 @@
+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

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: steroids
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Paul Reboh
+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
+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: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Steroids - Rails helpers
+test_files: []