wallaby 5.0.1 → 5.1.3

data/lib/helpers/wallaby/links_helper.rb

@@ -1,83 +1,152 @@
-module Wallaby::LinksHelper
-  def index_path(model_class = nil, extra_params = nil)
-    model_class   ||= current_model_class
-    extra_params  ||= {}
-    wallaby_engine.resources_path to_resources_name(model_class), extra_params
-  end
-
-  def new_path(model_class = nil)
-    model_class ||= current_model_class
-    wallaby_engine.new_resource_path to_resources_name model_class
-  end
-
-  def show_path(resource)
-    decorated = decorate resource
-    wallaby_engine.resource_path decorated.resources_name, decorated.primary_key_value
-  end
-
-  def edit_path(resource)
-    decorated = decorate resource
-    wallaby_engine.edit_resource_path decorated.resources_name, decorated.primary_key_value
-  end
-
-  def index_link(model_class = nil, html_options = {}, &block)
-    model_class ||= current_model_class
-    return if cannot? :index, model_class
-    block ||= -> { to_model_label model_class }
-
-    link_to index_path(model_class, html_options.delete(:extra_params)), html_options, &block
-  end
-
-  def new_link(model_class = nil, html_options = {}, &block)
-    model_class ||= current_model_class
-    return if cannot? :new, model_class
-
-    block ||= -> { "#{ ct 'link.new' } #{ to_model_label model_class }" }
-    html_options[:class] = 'text-success' unless html_options.has_key? :class
-
-    prepend_if html_options
-    link_to new_path(model_class), html_options, &block
-  end
-
-  def show_link(resource, html_options = {}, &block)
-    return if cannot? :show, extract(resource)
-
-    # NOTE: to_s is a must
-    # if a block is returning integer (e.g. `{ 1 }`)
-    # `link_to` will render blank text note inside hyper link
-    block ||= -> { decorate(resource).to_label.to_s }
-
-    link_to show_path(resource), html_options, &block
-  end
-
-  def edit_link(resource, html_options = {}, &block)
-    return if cannot? :edit, extract(resource)
-
-    block ||= -> { "#{ ct 'link.edit' } #{ decorate(resource).to_label }" }
-    html_options[:class] = 'text-warning' unless html_options.has_key? :class
-
-    link_to edit_path(resource), html_options, &block
-  end
-
-  def delete_link(resource, html_options = {}, &block)
-    return if cannot? :destroy, extract(resource)
-
-    block ||= -> { ct 'link.delete' }
-    html_options[:class]  = 'text-danger' unless html_options.has_key? :class
-    html_options[:method] ||= :delete
-    html_options[:data]   ||= {}
-    html_options[:data][:confirm] ||= ct('link.confirm.delete')
-
-    link_to show_path(resource), html_options, &block
-  end
-
-  def cancel_link(html_options = {}, &block)
-    block ||= -> { ct 'link.cancel' }
-    link_to :back, html_options, &block
-  end
-
-  def prepend_if(html_options = {})
-    prepend = html_options.delete :prepend
-    concat "#{ prepend } " if prepend.present?
+module Wallaby
+  # Links helper
+  module LinksHelper
+    # Permit the params used by Wallaby
+    def index_params
+      params.except(:resources, :utf8).permit(:filter, :page, :per, :q, :sort)
+    end
+
+    # Return link to index page by a given model class
+    # If user's not authorized, nil will be returned
+    # @param model_class [Class] model class
+    # @param url_params [ActionController::Parameters, Hash]
+    # @param html_options [Hash] (see ActionView::Helpers::UrlHelper#link_to)
+    # @return [String, nil] anchor element
+    def index_link(model_class, url_params: {}, html_options: {}, &block)
+      return if cannot? :index, model_class
+      html_options, block = LinkOptionsNormalizer.normalize(
+        html_options, block,
+        block: -> { to_model_label model_class }
+      )
+
+      path = index_path model_class, url_params: url_params
+      link_to path, html_options, &block
+    end
+
+    # Return link to create page by a given model class
+    # If user's not authorized, nil will be returned
+    # @param model_class [Class] model class
+    # @param options [Hash]
+    # @param html_options [Hash] (see ActionView::Helpers::UrlHelper#link_to)
+    # @return [String, nil] anchor element
+    def new_link(model_class, html_options: {}, &block)
+      return if cannot? :new, model_class
+      html_options, block = LinkOptionsNormalizer.normalize(
+        html_options, block,
+        class: 'resource__create',
+        block: -> { t 'links.new', model: to_model_label(model_class) }
+      )
+
+      link_to new_path(model_class), html_options, &block
+    end
+
+    # Return link to show page by a given model class
+    # If user's not authorized, resource label will be returned
+    # @param resource [Object, Wallaby::ResourceDecorator] model class
+    # @param options [Hash]
+    # @param html_options [Hash] (see ActionView::Helpers::UrlHelper#link_to)
+    # @return [String] anchor element / text
+    def show_link(resource, options: {}, html_options: {}, &block)
+      # NOTE: to_s is a must
+      # if a block is returning integer (e.g. `{ 1 }`)
+      # `link_to` will render blank text note inside hyper link
+      html_options, block = LinkOptionsNormalizer.normalize(
+        html_options, block,
+        block: -> { decorate(resource).to_label.to_s }
+      )
+
+      default = options[:readonly] && block.call || nil
+      return default if cannot? :show, extract(resource)
+      link_to show_path(resource), html_options, &block
+    end
+
+    # Return link to edit page by a given model class
+    # If user's not authorized, resource label will be returned
+    # @param resource [Object, Wallaby::ResourceDecorator] model class
+    # @param options [Hash]
+    # @param html_options [Hash] (see ActionView::Helpers::UrlHelper#link_to)
+    # @return [String] anchor element / text
+    def edit_link(resource, options: {}, html_options: {}, &block)
+      default = options[:readonly] && decorate(resource).to_label || nil
+      return default if cannot? :edit, extract(resource)
+
+      html_options, block = LinkOptionsNormalizer.normalize(
+        html_options, block,
+        class: 'resource__update',
+        block: -> { "#{t 'links.edit'} #{decorate(resource).to_label}" }
+      )
+
+      link_to edit_path(resource), html_options, &block
+    end
+
+    # Return link to delete action by a given model class
+    # If user's not authorized, nil will be returned
+    # @param resource [Object, Wallaby::ResourceDecorator] model class
+    # @param options [Hash]
+    # @param html_options [Hash] (see ActionView::Helpers::UrlHelper#link_to)
+    # @return [String, nil] anchor element
+    def delete_link(resource, html_options: {}, &block)
+      return if cannot? :destroy, extract(resource)
+
+      html_options, block = LinkOptionsNormalizer.normalize(
+        html_options, block,
+        class: 'resource__destroy',
+        block: -> { t 'links.delete' }
+      )
+
+      html_options[:method] ||= :delete
+      html_options[:data] ||= {}
+      html_options[:data][:confirm] ||= t 'links.confirm.delete'
+
+      link_to show_path(resource), html_options, &block
+    end
+
+    # Return link to cancel an action
+    # @param html_options [Hash] (see ActionView::Helpers::UrlHelper#link_to)
+    # @return [String] HTML anchor element
+    def cancel_link(html_options = {}, &block)
+      block ||= -> { t 'links.cancel' }
+      link_to :back, html_options, &block
+    end
+
+    # Url for index page
+    # @param model_class [Class]
+    # @param url_params [ActionController::Parameters, Hash]
+    # @return [String]
+    def index_path(model_class, url_params: {})
+      if url_params.is_a?(::ActionController::Parameters) \
+        && !url_params.permitted?
+        url_params = {}
+      end
+      wallaby_engine.resources_path \
+        to_resources_name(model_class), url_params.to_h
+    end
+
+    # Url for new resource form page
+    # @param model_class [Class]
+    # @return [String]
+    def new_path(model_class)
+      wallaby_engine.new_resource_path to_resources_name(model_class)
+    end
+
+    # Url for show page of given resource
+    # @param resource [Object]
+    # @return [String]
+    def show_path(resource)
+      decorated = decorate resource
+      return unless decorated.primary_key_value
+      wallaby_engine.resource_path \
+        decorated.resources_name, decorated.primary_key_value
+    end
+
+    # Url for edit form page of given resource
+    # @param resource [Object]
+    # @return [String]
+    def edit_path(resource)
+      decorated = decorate resource
+      return unless decorated.primary_key_value
+      wallaby_engine.edit_resource_path \
+        decorated.resources_name, decorated.primary_key_value
+    end
   end
 end

data/lib/helpers/wallaby/resources_helper.rb

@@ -1,55 +1,50 @@
-module Wallaby::ResourcesHelper
-  include Wallaby::FormHelper
-  include Wallaby::SortingHelper
-  include Wallaby::PaginatableHelper
-
-  def decorate(resource)
-    if resource.respond_to? :map # collection
-      decorator = Wallaby::DecoratorFinder.find_resource resource.first.class
-      resource.map do |item|
-        decorator.decorate item
-      end
-    else
-      decorator = Wallaby::DecoratorFinder.find_resource resource.class
-      decorator.decorate resource
+module Wallaby
+  # Resources helper
+  module ResourcesHelper
+    include FormHelper
+    include IndexHelper
+
+    def model_decorator(model_class)
+      Map.model_decorator_map model_class
     end
-  end
 
-  def extract(resource)
-    if resource.is_a? Wallaby::ResourceDecorator
-      resource.resource
-    else
-      resource
+    # Shortcut for `Wallaby.configuration.metadata
+    def default_metadata
+      Wallaby.configuration.metadata
     end
-  end
-
-  def model_decorator(model_class)
-    Wallaby::DecoratorFinder.find_model model_class
-  end
-
-  def model_servicer(model_decorator)
-    model_class = model_decorator.model_class
-    Wallaby::ServicerFinder.find(model_class).new model_class, model_decorator
-  end
-
-  def type_partial_render(options = {}, locals = {}, metadata_method = :show_metadata_of, &block)
-    decorated   = locals[:object]
-    field_name  = locals[:field_name].to_s
 
-    fail ArgumentError unless field_name.present? && decorated.is_a?(Wallaby::ResourceDecorator)
-
-    locals[:metadata] = decorated.send metadata_method, field_name
-    locals[:value]    = decorated.public_send field_name
+    # Wrap resource into a decorator
+    # @param resource [Object, Enumerable]
+    # @return
+    #   [Wallaby::ResourceDecorator, Enumerable<Wallaby::ResourceDecorator]
+    def decorate(resource)
+      return resource if resource.is_a? ResourceDecorator
+      return resource.map { |item| decorate item } if resource.respond_to? :map
+      decorator = Map.resource_decorator_map resource.class
+      decorator ? decorator.new(resource) : resource
+    end
 
-    render(options, locals, &block) or render('string', locals, &block)
-  end
+    # Get the origin resource object
+    # @param resource [Object, Wallaby::ResourceDecorator]
+    # @return [Object]
+    def extract(resource)
+      return resource.resource if resource.is_a? ResourceDecorator
+      resource
+    end
 
-  def index_type_partial_render(options = {}, locals = {}, &block)
-    type_partial_render options, locals, :index_metadata_of
-  end
+    # Render partial for index/show
+    def type_partial_render(options = {}, locals = {}, &block)
+      PartialRenderer.render self, options, locals, params[:action], &block
+    end
 
-  def show_title(decorated)
-    fail ArgumentError unless decorated.is_a? Wallaby::ResourceDecorator
-    [ to_model_label(decorated.model_class), decorated.to_label ].compact.join ': '
+    # 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
   end
 end

data/lib/helpers/wallaby/secure_helper.rb

@@ -1,25 +1,42 @@
-module Wallaby::SecureHelper
-  def user_portrait(user = current_user)
-    if user.respond_to? :email
-      image_source = "http#{ request.ssl? ? 's' : '' }://www.gravatar.com/avatar/#{ Digest::MD5.hexdigest user.email.downcase }"
-      image_tag image_source, class: 'hidden-xs user-portrait'
-    else
-      content_tag :i, nil, class: 'glyphicon glyphicon-user user-portrait'
+module Wallaby
+  # Secure helper
+  module SecureHelper
+    # Image portrait for given user
+    # @param user [Object]
+    # @return [String] IMG or I element
+    def user_portrait(user = current_user)
+      if user.respond_to? :email
+        https = "http#{request.ssl? ? 's' : EMPTY_STRING}"
+        email_md5 = Digest::MD5.hexdigest user.email.downcase
+        image_source = "#{https}://www.gravatar.com/avatar/#{email_md5}"
+        image_tag image_source, class: 'hidden-xs user-portrait'
+      else
+        content_tag :i, nil, class: 'fa fa-user user-portrait'
+      end
     end
-  end
 
-  def logout_path(user = current_user, app = main_app)
-    path = if defined? Devise
-      scope = Devise::Mapping.find_scope! user
-      "destroy_#{ scope }_session_path"
-    else
-      'logout_path'
+    # Logout path for given user
+    # @param user [Object]
+    # @param app [Object]
+    # @return [String] HTML anchor element
+    def logout_path(user = current_user, app = main_app)
+      # TODO: use authenticater
+      path =
+        if defined? ::Devise
+          scope = ::Devise::Mapping.find_scope! user
+          "destroy_#{scope}_session_path"
+        else
+          'logout_path'
+        end
+      app.public_send path if app.respond_to? path
     end
-    app.public_send path if app.respond_to? path
-  end
 
-  def logout_method
-    method = Array(Devise.sign_out_via).first if defined? Devise
-    method || :delete
+    # Logout method
+    # @return [String, Symbol]
+    def logout_method
+      # TODO: use authenticater
+      method = Array(Devise.sign_out_via).first if defined? Devise
+      method || :delete
+    end
   end
 end

data/lib/helpers/wallaby/styling_helper.rb

@@ -1,57 +1,66 @@
-module Wallaby::StylingHelper
-  def icon(icon_suffix, html_options = {}, &block)
-    html_options[:class] = Array html_options[:class]
-    html_options[:class] << "glyphicon glyphicon-#{ icon_suffix }"
+module Wallaby
+  # Styling helper
+  module StylingHelper
+    # Shortcut to build up the html options as keyword arguments
+    # @param string_or_array [String, Array]
+    # @return [Hash]
+    def html_classes(string_or_array)
+      { html_options: { class: string_or_array } }
+    end
 
-    content_tag :i, nil, html_options, &block
-  end
+    # Shortcut for fontawesome icons
+    # @param icon_suffix [String]
+    # @param html_options [Hash]
+    # @return [String] HTML I element
+    def fa_icon(icon_suffix, html_options = {}, &block)
+      html_options[:class] = Array html_options[:class]
+      html_options[:class] << "fa fa-#{icon_suffix}"
 
-  def itooltip(title, icon_suffix = 'info-sign', html_options = {})
-    html_options[:title] = title
-    (html_options[:data] ||= {}).merge! toggle: "tooltip", placement: "top"
+      content_tag :i, nil, html_options, &block
+    end
 
-    icon icon_suffix, html_options
-  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'
 
-  def ilink_to(options = nil, html_options = {})
-    icon_suffix = html_options.delete(:icon) || 'info-sign'
-    link_to options, html_options do
-      icon icon_suffix
+      fa_icon icon_suffix, html_options
     end
-  end
 
-  def imodal(title, body, html_options = {})
-    uuid = random_uuid
-    label ||= html_options.delete(:label) ||
-              html_options.delete(:icon) ||
-              icon('circle-arrow-up')
-    link_to(label, 'javascript:;', data: { toggle: 'modal', target: "##{ uuid }" }) +
-    content_tag(:div, id: uuid, class: 'modal fade', tabindex: -1, role: 'dialog') do
-      content_tag :div, class: 'modal-dialog modal-lg' do
-        content_tag :div, class: 'modal-content' do
-          content_tag(:div, class: 'modal-header') do
-            button_tag(type: 'button', class: 'close', data: { dismiss: 'modal' }, aria: { label: 'Close' }) do
-              content_tag :span, raw('&times;'), aria: { hidden: true }
-            end +
-            content_tag(:h4, title, class: 'modal-title')
-          end +
-          content_tag(:div, class: 'modal-body') do
-            body
-          end
-        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
-  end
 
-  def null
-    muted 'null'
-  end
+    # @return [String] grey null
+    def null
+      muted 'null'
+    end
 
-  def na
-    muted 'n/a'
-  end
+    # @return [String] grey N/A
+    def na
+      muted 'n/a'
+    end
 
-  def muted(content)
-    content_tag :i, "<#{ content }>", class: 'text-muted'
+    # Grey text
+    # @param text_content [String]
+    # @return [String] HTML I element
+    def muted(text_content)
+      content_tag :i, "<#{text_content}>", class: 'text-muted'
+    end
   end
 end

data/lib/interfaces/wallaby/mode.rb

@@ -1,17 +1,24 @@
-class Wallaby::Mode
-  INTERFACE_METHODS = %w( model_decorator model_finder model_operator )
+module Wallaby
+  # This is the abstract class that all ORM modes to have implemented.
+  class Mode
+    INTERFACE_METHODS = %w(
+      model_decorator model_finder
+      model_service_provider model_pagination_provider
+    ).freeze
 
-  INTERFACE_METHODS.each do |method_id|
-    define_singleton_method method_id do
-      begin
-        method_class  = __callee__.to_s.classify
-        class_name    = "#{ name }::#{ method_class }"
-        parent_class  = "Wallaby::#{ method_class }".constantize
-        class_name.constantize.tap do |klass|
-          fail Wallaby::InvalidError, "#{ klass } must inherit #{ parent_class }" unless klass < parent_class
+    INTERFACE_METHODS.each do |method_id|
+      define_singleton_method method_id do
+        begin
+          method_class  = __callee__.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, "#{klass} must inherit #{parent_class}"
+          end
+        rescue NameError
+          raise NotImplemented, class_name
         end
-      rescue NameError
-        fail Wallaby::NotImplemented, class_name
       end
     end
   end