wallaby-core 0.1.0

data/lib/helpers/wallaby/resources_helper.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Resources helper
+  module ResourcesHelper
+    include BaseHelper
+    include FormHelper
+    include IndexHelper
+
+    include Authorizable
+    include Decoratable
+    include Paginatable
+    include Resourcable
+    include Servicable
+    include Themeable
+
+    # @deprecated Use {#type_render} instead. It will be removed from 5.3.*
+    def type_partial_render(options = {}, locals = {}, &block)
+      Utils.deprecate 'deprecation.type_partial_render', caller: caller
+      type_render options, locals, &block
+    end
+
+    # Render type cell/partial
+    # @param partial_name [String]
+    # @param locals [Hash]
+    def type_render(partial_name = '', locals = {}, &block)
+      TypeRenderer.render self, partial_name, locals, &block
+    end
+
+    # Title for show page of given resource
+    # @param decorated [Wallaby::ResourceDecorator]
+    # @return [String]
+    def show_title(decorated)
+      raise ::ArgumentError unless decorated.is_a? ResourceDecorator
+
+      [
+        to_model_label(decorated.model_class), decorated.to_label
+      ].compact.join ': '
+    end
+
+    # To find the first field that meets given conditions.
+    # @example To find summary field whose name contains _summary_ and type is **string**:
+    #   first_field_by({ name: /summary/, type: 'string' })
+    # @param conditions [Array<Hash>]
+    # @return [String, Symbol] field name when found
+    # @return [nil] when not found
+    def first_field_by(*conditions)
+      fields = block_given? ? yield : current_fields
+      FieldUtils.first_field_by(*conditions, fields)
+    end
+  end
+end

data/lib/helpers/wallaby/secure_helper.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Secure helper
+  module SecureHelper
+    # Image portrait for given user.
+    #
+    # - if email is present, a gravatar image tag will be returned
+    # - otherwise, an user icon will be returned
+    # @param user [Object]
+    # @return [String] IMG or I element
+    def user_portrait(user = current_user)
+      email_method = security.email_method || :email
+      email = try_to user, email_method
+      if email.present?
+        https = "http#{request.ssl? ? 's' : EMPTY_STRING}"
+        email_md5 = ::Digest::MD5.hexdigest email.downcase
+        image_source = "#{https}://www.gravatar.com/avatar/#{email_md5}"
+        image_tag image_source, class: 'user'
+      else
+        fa_icon 'user'
+      end
+    end
+
+    # Logout path for given user
+    # @see Wallaby::Configuration::Security#logout_path
+    # @param user [Object]
+    # @param app [Object]
+    # @return [String] URL to log out
+    def logout_path(user = current_user, app = main_app)
+      path = security.logout_path
+      path ||=
+        if defined? ::Devise
+          scope = ::Devise::Mapping.find_scope! user
+          "destroy_#{scope}_session_path"
+        end
+      try_to app, path
+    end
+
+    # Logout method for given user
+    # @see Wallaby::Configuration::Security#logout_method
+    # @param user [Object]
+    # @return [String, Symbol] http method to log out
+    def logout_method(user = current_user)
+      http_method = security.logout_method
+      http_method ||
+        if defined? ::Devise
+          scope = ::Devise::Mapping.find_scope! user
+          mapping = ::Devise.mappings[scope]
+          mapping.sign_out_via
+        end
+    end
+  end
+end

data/lib/helpers/wallaby/styling_helper.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Helper methods to build custom elements
+  module StylingHelper
+    # Shortcut to build up the HTML options as keyword arguments
+    # @param string_or_array [String, Array<String>]
+    # @param options [Hash]
+    # @return [Hash]
+    def html_classes(string_or_array, options = {})
+      { html_options: options.merge(class: string_or_array) }
+    end
+
+    # Shortcut to generate FontAwesome icon using tag <i>.
+    # @overload fa_icon(*names, html_options)
+    #   @param names [Array<String>] names of the icon
+    #   @param html_options [Hash] HTML options for tag <i>
+    # @return [String] HTML I element
+    def fa_icon(*args, &block)
+      html_options = args.extract_options!
+      html_options[:class] = Array html_options[:class]
+      html_options[:class] << 'fa'
+      args.each { |suffix| html_options[:class] << "fa-#{fa_map suffix}" }
+
+      content_tag :i, nil, html_options, &block
+    end
+
+    # Build up tooltip
+    # @param title [String]
+    # @param icon_suffix [String]
+    # @param html_options [Hash]
+    # @return [String] tooltip HTML
+    def itooltip(title, icon_suffix = 'info-circle', html_options = {})
+      html_options[:title] = title
+      (html_options[:data] ||= {}).merge! toggle: 'tooltip', placement: 'top'
+
+      fa_icon icon_suffix, html_options
+    end
+
+    # Build up modal
+    # @param title [String]
+    # @param body [String]
+    # @param html_options [Hash]
+    # @return [String] modal HTML
+    def imodal(title, body, html_options = {})
+      label ||= html_options.delete(:label) \
+                  || html_options.delete(:icon) || fa_icon('clone')
+      content_tag :span, class: 'modaler' do
+        concat link_to(label, '#', data: { target: '#imodal', toggle: 'modal' })
+        concat content_tag(:span, title, class: 'modaler__title')
+        concat content_tag(:span, body, class: 'modaler__body')
+      end
+    end
+
+    # @return [String] grey null
+    def null
+      muted t 'labels.empty'
+    end
+
+    # @return [String] grey N/A
+    def na
+      muted t 'labels.na'
+    end
+
+    # Grey text
+    # @param text_content [String]
+    # @return [String] HTML I element
+    def muted(text_content)
+      content_tag :i, "<#{text_content}>", class: 'text-muted'
+    end
+
+    # @param name [String]
+    # @return [String] FontAwesome icon name
+    def fa_map(name, major = nil)
+      @map ||= begin
+        major ||= Gem.loaded_specs['font-awesome-sass'].try(:version).try(:segments).try(:first)
+        t("fa.v#{major}").with_indifferent_access
+      end
+      @map[name] || name
+    end
+  end
+end

data/lib/interfaces/wallaby/mode.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # This is the interface that all ORM modes should inherit from and implement.
+  class Mode
+    class << self
+      # @see Wallaby::ModelDecorator
+      # @return [Class] model decorator for the mode
+      def model_decorator
+        check_and_constantize __callee__
+      end
+
+      # @see Wallaby::ModelFinder
+      # @return [Class] model finder for the mode
+      def model_finder
+        check_and_constantize __callee__
+      end
+
+      # @see Wallaby::ModelServiceProvider
+      # @return [Class] service provider for the mode
+      def model_service_provider
+        check_and_constantize __callee__
+      end
+
+      # @see Wallaby::ModelPaginationProvider
+      # @return [Class] pagination provider for the mode
+      # @since 5.2.0
+      def model_pagination_provider
+        check_and_constantize __callee__
+      end
+
+      # @see Wallaby::ModelPaginationProvider
+      # @return [Class] pagination provider for the mode
+      # @since 5.2.0
+      def default_authorization_provider
+        check_and_constantize __callee__
+      end
+
+      # Return a list of authorization providers for authorizer to detect which one to use.
+      # @see Wallaby::ModelAuthorizationProvider
+      # @return [ActiveSupport::HashWithIndifferentAccess<String, Class>] authorization provider hash
+      # @since 5.2.0
+      def model_authorization_providers(classes = ModelAuthorizationProvider.descendants)
+        # NOTE: make sure default provider always comes last
+        @model_authorization_providers ||=
+          classes
+          .select { |klass| klass.name.include? name }
+          .sort_by { |klass| klass.provider_name == DEFAULT_PROVIDER ? 1 : 0 }
+          .each_with_object(::ActiveSupport::HashWithIndifferentAccess.new) do |klass, hash|
+            hash[klass.provider_name] = klass
+          end
+      end
+
+      private
+
+      # @return [Class] constantized class
+      def check_and_constantize(method_id)
+        method_class = method_id.to_s.classify
+        class_name = "#{name}::#{method_class}"
+        parent_class = "Wallaby::#{method_class}".constantize
+        class_name.constantize.tap do |klass|
+          next if klass < parent_class
+
+          raise InvalidError, I18n.t('wallaby.mode.inherit_required', klass: klass, parent: parent_class)
+        end
+      rescue NameError => e
+        Rails.logger.error e
+        raise NotImplemented, class_name
+      end
+    end
+  end
+end

data/lib/interfaces/wallaby/model_authorization_provider.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Model Authorizer interface.
+  # @since 5.2.0
+  class ModelAuthorizationProvider
+    class << self
+      # @!attribute [w] provider_name
+      attr_writer :provider_name
+
+      # @!attribute [r] provider_name
+      # This is the provider name that can be set in Wallaby::ModelAuthorizer subclasses.
+      # @see Wallaby::ModelAuthorizer.provider_name
+      # @return [String/Symbol] provider name
+      def provider_name
+        @provider_name || name.demodulize.gsub(/(Authorization)?Provider/, EMPTY_STRING).underscore
+      end
+
+      # @note Template method to check and see if current provider is in used.
+      # @param _context [ActionController::Base]
+      # @raise [Wallaby::NotImplemented]
+      def available?(_context)
+        raise NotImplemented
+      end
+
+      # @note Template method to pull out the args required for contruction from context.
+      # @param _context [ActionController::Base]
+      # @raise [Wallaby::NotImplemented]
+      def args_from(_context)
+        raise NotImplemented
+      end
+    end
+
+    # @!attribute [r] context
+    # @return [ActionController::Base]
+    attr_reader :context
+
+    # @!attribute [r] user
+    # @return [Object]
+    attr_reader :user
+
+    # Empty initialize that accepts all sorts of args
+    def initialize(*); end
+
+    # @note It can be overridden in subclasses for customization purpose.
+    # This is the template method to check user's permission for given action on given subject.
+    # @param _action [Symbol, String]
+    # @param _subject [Object, Class]
+    # @raise [Wallaby::NotImplemented]
+    def authorize(_action, _subject)
+      raise NotImplemented
+    end
+
+    # @note It can be overridden in subclasses for customization purpose.
+    # This is the template method to check if user has permission for given action on given subject.
+    # @param _action [Symbol, String]
+    # @param _subject [Object, Class]
+    # @raise [Wallaby::NotImplemented]
+    def authorized?(_action, _subject)
+      raise NotImplemented
+    end
+
+    # @note It can be overridden in subclasses for customization purpose.
+    # This is the template method to check if user has no permission for given action on given subject.
+    # @param action [Symbol, String]
+    # @param subject [Object, Class]
+    # @raise [Wallaby::NotImplemented]
+    def unauthorized?(action, subject)
+      !authorized?(action, subject)
+    end
+
+    # @note It can be overridden in subclasses for customization purpose.
+    # This is the template method to restrict user's access to certain scope.
+    # @param _action [Symbol, String]
+    # @param _scope [Object]
+    # @raise [Wallaby::NotImplemented]
+    def accessible_for(_action, _scope)
+      raise NotImplemented
+    end
+
+    # @note It can be overridden in subclasses for customization purpose.
+    # This is the template method to restrict user's modification to certain fields of given subject.
+    # @param _action [Symbol, String]
+    # @param _subject [Object]
+    # @raise [Wallaby::NotImplemented]
+    def attributes_for(_action, _subject)
+      raise NotImplemented
+    end
+
+    # @note It can be overridden in subclasses for customization purpose.
+    # This is the template method to restrict user's mass assignment to certain fields of given subject.
+    # @param _action [Symbol, String]
+    # @param _subject [Object]
+    # @raise [Wallaby::NotImplemented]
+    def permit_params(_action, _subject)
+      raise NotImplemented
+    end
+  end
+end

data/lib/interfaces/wallaby/model_decorator.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Model Decorator interface, designed to maintain metadata for all fields from the data source (database/api)
+  # @see Wallaby::ResourceDecorator for more information on how to customize metadata
+  class ModelDecorator
+    include Fieldable
+
+    # Initialize with model class
+    # @param model_class [Class]
+    def initialize(model_class)
+      @model_class = model_class
+    end
+
+    # @!attribute [r] model_class
+    # @return [Class]
+    attr_reader :model_class
+
+    # @!attribute [r] fields
+    # @note to be implemented in subclasses.
+    # Origin fields metadata.
+    #
+    # Initially, {#index_fields}, {#show_fields} and {#form_fields} are copies of it.
+    # @return [ActiveSupport::HashWithIndifferentAccess]
+    def fields
+      raise NotImplemented
+    end
+
+    # @!attribute [w] model_class
+    def fields=(fields)
+      @fields = fields.with_indifferent_access
+    end
+
+    # @!attribute [r] index_fields
+    # @note to be implemented in subclasses.
+    # Fields metadata for `index` page.
+    # @return [ActiveSupport::HashWithIndifferentAccess]
+    def index_fields
+      raise NotImplemented
+    end
+
+    # @!attribute [w] index_fields
+    def index_fields=(fields)
+      @index_fields = fields.with_indifferent_access
+    end
+
+    # @!attribute [w] index_field_names
+    attr_writer :index_field_names
+
+    # @!attribute [r] index_field_names
+    # A list of field names for `index` page
+    # @return [Array<String, Symbol>]
+    def index_field_names
+      @index_field_names ||= reposition index_fields.keys, primary_key
+    end
+
+    # @!attribute [r] show_fields
+    # @note to be implemented in subclasses.
+    # Fields metadata for `show` page.
+    # @return [ActiveSupport::HashWithIndifferentAccess]
+    def show_fields
+      raise NotImplemented
+    end
+
+    # @!attribute [w] show_fields
+    def show_fields=(fields)
+      @show_fields = fields.with_indifferent_access
+    end
+
+    # @!attribute [w] show_field_names
+    attr_writer :show_field_names
+
+    # @!attribute [r] show_field_names
+    # A list of field names for `show` page
+    # @return [Array<String, Symbol>]
+    def show_field_names
+      @show_field_names ||= reposition show_fields.keys, primary_key
+    end
+
+    # @!attribute [r] form_fields
+    # @note to be implemented in subclasses.
+    # Fields metadata for form (`new`/`edit`) page.
+    # @return [ActiveSupport::HashWithIndifferentAccess]
+    def form_fields
+      raise NotImplemented
+    end
+
+    # @!attribute [w] form_fields
+    def form_fields=(fields)
+      @form_fields = fields.with_indifferent_access
+    end
+
+    # @!attribute [w] form_field_names
+    attr_writer :form_field_names
+
+    # @!attribute [r] form_field_names
+    # A list of field names for form (`new`/`edit`) page
+    # @return [Array<String, Symbol>]
+    def form_field_names
+      @form_field_names ||= reposition form_fields.keys, primary_key
+    end
+
+    # @!attribute [r] filters
+    # @note to be implemented in subclasses.
+    # Filter metadata for index page.
+    # @return [ActiveSupport::HashWithIndifferentAccess]
+    def filters
+      @filters ||= ::ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    # @note to be implemented in subclasses.
+    # Validation error for given resource
+    # @param _resource [Object]
+    # @return [ActiveModel::Errors, Hash]
+    def form_active_errors(_resource)
+      raise NotImplemented
+    end
+
+    # @!attribute [w] primary_key
+    attr_writer :primary_key
+
+    # @!attribute [r] primary_key
+    # @note to be implemented in subclasses.
+    # @return [String] primary key name
+    def primary_key
+      raise NotImplemented
+    end
+
+    # @note to be implemented in subclasses.
+    # To guess the title for a resource.
+    #
+    # This title will be used on the following places:
+    #
+    # - page title on show page
+    # - in the response for autocomplete association field
+    # - title of show link for a resource
+    # @param _resource [Object]
+    # @return [String] title of current resource
+    def guess_title(_resource)
+      raise NotImplemented
+    end
+
+    # @return [String]
+    # @see Wallaby::Map.resources_name_map
+    def resources_name
+      Map.resources_name_map model_class
+    end
+
+    protected
+
+    # Move primary key to the front for given field names.
+    # @param field_names [Array<String, Symbol>] field names
+    # @param primary_key [String, Symbol] primary key name
+    # @return [Array<String, Symbol>]
+    # a new list of field names that primary key goes first
+    def reposition(field_names, primary_key)
+      field_names.unshift(primary_key.to_s).uniq
+    end
+
+    # Validate presence of a type for given field name
+    # @param type [String, Symbol, nil]
+    # @return [String, Symbol] type
+    # @raise [ArgumentError] when type is nil
+    def validate_presence_of(field_name, type)
+      type || raise(::ArgumentError, I18n.t('errors.invalid.type_required', field_name: field_name))
+    end
+  end
+end