wallaby-core 0.1.0

data/lib/concerns/wallaby/servicable.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Servicer related attributes
+  module Servicable
+    # Configurable attribute
+    module ClassMethods
+      # @!attribute [w] model_servicer
+      def model_servicer=(model_servicer)
+        ModuleUtils.inheritance_check model_servicer, application_servicer
+        @model_servicer = model_servicer
+      end
+
+      # @!attribute [r] model_servicer
+      # If Wallaby doesn't get it right, please specify the **model_servicer**.
+      # @example To set model servicer
+      #   class Admin::ProductionsController < Admin::ApplicationController
+      #     self.model_servicer = ProductServicer
+      #   end
+      # @return [Class] model servicer
+      # @raise [ArgumentError] when **model_servicer** doesn't inherit from **application_servicer**
+      # @see Wallaby::ModelServicer
+      # @since 5.2.0
+      attr_reader :model_servicer
+
+      # @!attribute [w] application_servicer
+      def application_servicer=(application_servicer)
+        ModuleUtils.inheritance_check model_servicer, application_servicer
+        @application_servicer = application_servicer
+      end
+
+      # @!attribute [r] application_servicer
+      # The **application_servicer** is as the base class of {#model_servicer}.
+      # @example To set application decorator:
+      #   class Admin::ApplicationController < Wallaby::ResourcesController
+      #     self.application_servicer = AnotherApplicationServicer
+      #   end
+      # @return [Class] application decorator
+      # @raise [ArgumentError] when **model_servicer** doesn't inherit from **application_servicer**
+      # @see Wallaby::ModelServicer
+      # @since 5.2.0
+      def application_servicer
+        @application_servicer ||= ModuleUtils.try_to superclass, :application_servicer
+      end
+    end
+
+    # Model servicer for current modal class. It comes from:
+    #
+    # - controller configuration {Wallaby::Servicable::ClassMethods#model_servicer .model_servicer}
+    # - a generic servicer based on {Wallaby::Servicable::ClassMethods#application_servicer .application_servicer}
+    # @return [Wallaby::ModelServicer] model servicer
+    # @since 5.2.0
+    def current_servicer
+      @current_servicer ||=
+        (controller_to_get(:model_servicer) \
+          || Map.servicer_map(current_model_class, controller_to_get(:application_servicer))).try do |klass|
+          Rails.logger.info %(  - Current servicer: #{klass})
+          klass.new current_model_class, current_authorizer, current_model_decorator
+        end
+    end
+
+    # @deprecated Use {#current_servicer} instead. It will be removed from 5.3.*
+    def current_model_service
+      Utils.deprecate 'deprecation.current_model_service', caller: caller
+      current_servicer
+    end
+  end
+end

data/lib/concerns/wallaby/shared_helpers.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Shared helpers
+  module SharedHelpers
+    protected
+
+    # Fetch value for given attribute.
+    #
+    # If it's used in controller, it will fetch it from class attribute.
+    # If it's used in view, it will fetch it from controller.
+    # @param attribute_name [String, Symbol] instance attribute name
+    # @param class_attribute_name [String, Symbol] class attribute name
+    # @return [Object] the value
+    def controller_to_get(attribute_name, class_attribute_name = nil)
+      class_attribute_name ||= attribute_name
+      return ModuleUtils.try_to self.class, class_attribute_name if is_a? ::ActionController::Base # controller?
+
+      ModuleUtils.try_to controller, attribute_name # view?
+    end
+  end
+end

data/lib/concerns/wallaby/themeable.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Theme related methods
+  module Themeable
+    # Configurable attributes
+    module ClassMethods
+      # @!attribute [w] theme_name
+      def theme_name=(theme_name)
+        layout theme_name
+        @theme_name = theme_name
+      end
+
+      # @!attribute [r] theme_name
+      # The theme name is used to apply a set of frontend (html/css/javascript) implementation.
+      #
+      # When theme name is set to e.g. `custom_theme`, the following changes will be made:
+      #
+      # - layout will be set to the same name `custom_theme`
+      # - it will be added to the partial lookup prefixes right on top of `wallaby/resources` prefix.
+      #
+      # Once theme name is set, all its controller subclasses will inherit the same theme name
+      # @example To set an theme name:
+      #   class Admin::ApplicationController < Wallaby::ResourcesController
+      #     self.theme_name = 'admin_theme'
+      #   end
+      # @return [String, Symbol, nil] theme name
+      # @since 5.2.0
+      def theme_name
+        @theme_name ||= ModuleUtils.try_to superclass, :theme_name
+      end
+    end
+
+    # @return [String, Symbol, nil] theme name
+    # @since 5.2.0
+    def current_theme_name
+      controller_to_get __callee__, :theme_name
+    end
+  end
+end

data/lib/decorators/wallaby/resource_decorator.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Resource Decorator base class, designed for decorator pattern.
+  # @see Wallaby::ModelDecorator
+  class ResourceDecorator
+    extend Baseable::ClassMethods
+
+    DELEGATE_METHODS =
+      ModelDecorator.public_instance_methods(false) + Fieldable.public_instance_methods(false) - %i(model_class)
+
+    class << self
+      delegate(*DELEGATE_METHODS, to: :model_decorator, allow_nil: true)
+
+      # @!attribute [w] model_class
+      attr_writer :model_class
+
+      # @!attribute [r] model_class
+      # Return associated model class, e.g. return **Product** for **ProductDecorator**.
+      #
+      # If Wallaby can't recognise the model class for Decorator, it's required to be configured as below example:
+      # @example To configure model class
+      #   class Admin::ProductDecorator < Admin::ApplicationDecorator
+      #     self.model_class = Product
+      #   end
+      # @example To configure model class for version below 5.2.0
+      #   class Admin::ProductDecorator < Admin::ApplicationDecorator
+      #     def self.model_class
+      #       Product
+      #     end
+      #   end
+      # @return [Class] assoicated model class
+      # @return [nil] if current class is marked as base class
+      # @return [nil] if current class is the same as the value of {Wallaby::Configuration::Mapping#resource_decorator}
+      # @return [nil] if current class is {Wallaby::ResourceDecorator}
+      # @return [nil] if assoicated model class is not found
+      def model_class
+        return unless self < ResourceDecorator
+        return if base_class? || self == Wallaby.configuration.mapping.resource_decorator
+
+        @model_class ||= Map.model_class_map(name.gsub(/(^#{namespace}::)|(Decorator$)/, EMPTY_STRING))
+      end
+
+      # @!attribute [w] application_decorator
+      def application_decorator=(application_decorator)
+        ModuleUtils.inheritance_check self, application_decorator
+        @application_decorator = application_decorator
+      end
+
+      # @note This attribute have to be the same as the one defined in the controller in order to make things working.
+      #   see {Wallaby::Decoratable::ClassMethods#application_decorator}
+      # @!attribute [r] application_decorator
+      # Assoicated base class.
+      #
+      # Wallaby will try to get the application decorator class from current class's ancestors chain.
+      # For instance, if current class is **ProductDecorator**, and it inherits from **CoreDecorator**,
+      # then Wallaby will return application decorator class **CoreDecorator**.
+      #
+      # However, there is a chance that Wallaby doesn't get it right.
+      # For instance, if **CoreDecorator** in the above example inherits from **Admin::ApplicationDecorator**, and
+      # the controller that needs **ProductDecorator** has set its **application_decorator** to
+      # **Admin::ApplicationDecorator**, then it's needed to configure **application_decorator** as the example
+      # describes
+      # @example To set application decorator class
+      #   class ProductController < Admin::ApplicationController
+      #     self.application_decorator = Admin::ApplicationDecorator
+      #   end
+      #
+      #   class CoreDecorator < Admin::ApplicationDecorator
+      #     base_class!
+      #   end
+      #
+      #   class ProductDecorator < CoreDecorator
+      #     self.application_decorator = Admin::ApplicationDecorator
+      #   end
+      # @return [Class] assoicated base class.
+      # @return [nil] if assoicated base class is not found from its ancestors chain
+      # @raise [ArgumentError] when current class doesn't inherit from given value
+      # @since 5.2.0
+      def application_decorator
+        @application_decorator ||= ancestors.find { |parent| parent < ResourceDecorator && !parent.model_class }
+      end
+
+      # Return associated model decorator.
+      #
+      # Fetch model decorator instance from cached map using keys {.model_class} and {.application_decorator}
+      # so that model decorator can be used in its sub classes declaration/scope.
+      # @param model_class [Class]
+      # @return [Wallaby::ModelDecorator]
+      def model_decorator(model_class = self.model_class)
+        return unless self < ResourceDecorator || model_class
+
+        Map.model_decorator_map model_class, application_decorator
+      end
+
+      # @!attribute [w] h
+      attr_writer :h
+
+      # @!attribute [r] h
+      # @return [ActionView::Base]
+      #   {Wallaby::Configuration::Mapping#resources_controller resources controller}'s helpers
+      def h
+        @h ||= Wallaby.configuration.mapping.resources_controller.helpers
+      end
+    end
+
+    # @!attribute [r] resource
+    # @return [Object]
+    attr_reader :resource
+
+    # @!attribute [r] model_decorator
+    # @return [Wallaby::ModelDecorator]
+    attr_reader :model_decorator
+
+    # @return [ActionView::Base]
+    #   {Wallaby::Configuration::Mapping#resources_controller resources controller}'s helpers
+    # @see .h
+    def h
+      self.class.h
+    end
+
+    delegate(*DELEGATE_METHODS, to: :model_decorator)
+    # NOTE: this delegation is to make url helper method working properly with resource decorator instance
+    delegate :to_s, :to_param, to: :resource
+
+    # @param resource [Object]
+    def initialize(resource)
+      @resource = resource
+      @model_decorator = self.class.model_decorator(model_class)
+    end
+
+    # @return [Class] resource's class
+    def model_class
+      resource.class
+    end
+
+    # @param field_name [String, Symbol]
+    # @return [Object] value of given field name
+    def value_of(field_name)
+      return unless field_name
+
+      resource.try field_name
+    end
+
+    # Guess the title for given resource.
+    #
+    # It falls back to primary key value when no text field is found.
+    # @return [String] a label
+    def to_label
+      # NOTE: `.to_s` at the end is to ensure String is returned that won't cause any
+      # issue when `#to_label` is used in a link_to block. Coz integer is ignored.
+      (model_decorator.guess_title(resource) || primary_key_value).to_s
+    end
+
+    # @return [Hash, Array] validation/result errors
+    def errors
+      model_decorator.form_active_errors(resource)
+    end
+
+    # @return [Object] primary key value
+    def primary_key_value
+      resource.try primary_key
+    end
+
+    # @return [ActiveModel::Name]
+    def model_name
+      ModuleUtils.try_to(resource, :model_name) || ActiveModel::Name.new(model_class)
+    end
+
+    # @return [nil] if no primary key
+    # @return [Array<String>] primary key
+    def to_key
+      key = ModuleUtils.try_to(resource, primary_key)
+      key ? [key] : nil
+    end
+
+    # Delegate missing method to {#resource}
+    def method_missing(method_id, *args, &block)
+      return super unless resource.respond_to? method_id
+
+      resource.try method_id, *args, &block
+    end
+
+    # Delegate missing method check to context
+    def respond_to_missing?(method_id, _include_private)
+      resource.respond_to?(method_id) || super
+    end
+  end
+end

data/lib/errors/wallaby/cell_handling.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class CellHandling < ::StandardError
+  end
+end

data/lib/errors/wallaby/forbidden.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class Forbidden < GeneralError
+  end
+end

data/lib/errors/wallaby/general_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class GeneralError < ::StandardError
+  end
+end

data/lib/errors/wallaby/invalid_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class InvalidError < GeneralError
+  end
+end

data/lib/errors/wallaby/model_not_found.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Model not found error
+  class ModelNotFound < NotFound
+    # @return [String] not found error message
+    def message
+      I18n.t 'errors.not_found.model', model: super
+    end
+  end
+end

data/lib/errors/wallaby/not_authenticated.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class NotAuthenticated < GeneralError
+  end
+end

data/lib/errors/wallaby/not_found.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class NotFound < GeneralError
+  end
+end

data/lib/errors/wallaby/not_implemented.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class NotImplemented < GeneralError
+  end
+end

data/lib/errors/wallaby/resource_not_found.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Resource not found error
+  class ResourceNotFound < NotFound
+    # @return [String] resource not found error message
+    def message
+      I18n.t 'errors.not_found.resource', resource: super
+    end
+  end
+end

data/lib/errors/wallaby/unprocessable_entity.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Wallaby
+  class UnprocessableEntity < GeneralError
+  end
+end

data/lib/forms/wallaby/form_builder.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Custom form builder to add more helper functions
+  class FormBuilder < ::ActionView::Helpers::FormBuilder
+    # Return error class if there is error
+    # @param field_name [String/Symbol]
+    # @return [String]
+    def error_class(field_name)
+      'has-error' if object.errors[field_name].present?
+    end
+
+    # Build up the HTML for displaying error messages
+    # @param field_name [String/Symbol]
+    # @return [String] HTML
+    def error_messages(field_name)
+      errors = Array object.errors[field_name]
+      return if errors.blank?
+
+      content_tag :ul, class: 'errors' do
+        errors.each do |message|
+          concat content_tag :li, content_tag(
+            :small, raw(message) # rubocop:disable Rails/OutputSafety
+          )
+        end
+      end
+    end
+
+    # Extend label to accept proc type `text` argument
+    # @see ActionView::Helpers::FormBuilder#label
+    def label(method, text = nil, options = {}, &block)
+      text = instance_exec(&text) if text.is_a?(Proc)
+      super
+    end
+
+    # Extend select to accept proc type `choices` argument
+    # @see ActionView::Helpers::FormBuilder#select
+    def select(method, choices = nil, options = {}, html_options = {}, &block)
+      choices = instance_exec(&choices) if choices.is_a?(Proc)
+      super
+    end
+
+    protected
+
+    # Delegate missing method to `@template`
+    def method_missing(method, *args, &block)
+      return super unless @template.respond_to? method
+
+      # Delegate the method so that we don't come in here the next time
+      # when same method is called
+      self.class.delegate method, to: :@template
+      @template.public_send method, *args, &block
+    end
+
+    # Delegate missing method check to `@template`
+    def respond_to_missing?(method, _include_private)
+      @template.respond_to?(method) || super
+    end
+  end
+end