wallaby 4.1.6

data/lib/helpers/wallaby/links_helper.rb

@@ -0,0 +1,83 @@
+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?
+  end
+end

data/lib/helpers/wallaby/paginatable_helper.rb

@@ -0,0 +1,9 @@
+module Wallaby::PaginatableHelper
+  def paginatable?(collection)
+    defined?(Kaminari) && collection.present? && collection.respond_to?(:total_pages)
+  end
+
+  def custom_pagination_stats(collection)
+    "Showing #{ content_tag :b, collection.size }".html_safe
+  end
+end

data/lib/helpers/wallaby/resources_helper.rb

@@ -0,0 +1,55 @@
+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
+    end
+  end
+
+  def extract(resource)
+    if resource.is_a? Wallaby::ResourceDecorator
+      resource.resource
+    else
+      resource
+    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
+
+    render(options, locals, &block) or render('string', locals, &block)
+  end
+
+  def index_type_partial_render(options = {}, locals = {}, &block)
+    type_partial_render options, locals, :index_metadata_of
+  end
+
+  def show_title(decorated)
+    fail ArgumentError unless decorated.is_a? Wallaby::ResourceDecorator
+    [ to_model_label(decorated.model_class), decorated.to_label ].compact.join ': '
+  end
+end

data/lib/helpers/wallaby/secure_helper.rb

@@ -0,0 +1,25 @@
+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'
+    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'
+    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
+  end
+end

data/lib/helpers/wallaby/sorting_helper.rb

@@ -0,0 +1,43 @@
+module Wallaby::SortingHelper
+  def sort_link(field_name, model_decorator = current_model_decorator)
+    metadata = model_decorator.index_metadata_of field_name
+
+    if metadata[:is_origin] && !metadata[:is_association] || metadata[:sort_field_name]
+      sort_field_name = metadata[:sort_field_name] || field_name
+      extra_params = next_sort_param sort_field_name
+      index_link(model_decorator.model_class, extra_params: extra_params) { metadata[:label] }
+    else
+      metadata[:label]
+    end
+  end
+
+  def sort_hash
+    @sort_hash ||= begin
+      array = params[:sort].to_s.split(%r(\s*,\s*)).map{ |v| v.split %r(\s+) }
+      Wallaby::Utils.to_hash array
+    end
+  end
+
+  def next_sort_param(field_name)
+    field_name  = field_name.to_s
+    orders      = [ 'asc', 'desc', nil ]
+    clean_params.tap do |hash|
+      sortings = sort_hash.dup
+      next_index = (orders.index(sortings[field_name]) + 1) % orders.length
+      if orders[next_index].nil?
+        sortings.delete field_name
+      else
+        sortings[field_name] = orders[next_index]
+      end
+      if sortings.present?
+        hash[:sort] = sortings.to_a.map{ |v| v.join ' ' }.join ','
+      else
+        hash.delete :sort
+      end
+    end
+  end
+
+  def sort_class(field_name)
+    sort_hash[ field_name.to_s ]
+  end
+end

data/lib/helpers/wallaby/styling_helper.rb

@@ -0,0 +1,57 @@
+module Wallaby::StylingHelper
+  def icon(icon_suffix, html_options = {}, &block)
+    html_options[:class] = Array html_options[:class]
+    html_options[:class] << "glyphicon glyphicon-#{ icon_suffix }"
+
+    content_tag :i, nil, html_options, &block
+  end
+
+  def itooltip(title, icon_suffix = 'info-sign', html_options = {})
+    html_options[:title] = title
+    (html_options[:data] ||= {}).merge! toggle: "tooltip", placement: "top"
+
+    icon icon_suffix, html_options
+  end
+
+  def ilink_to(options = nil, html_options = {})
+    icon_suffix = html_options.delete(:icon) || 'info-sign'
+    link_to options, html_options do
+      icon icon_suffix
+    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
+      end
+    end
+  end
+
+  def null
+    muted 'null'
+  end
+
+  def na
+    muted 'n/a'
+  end
+
+  def muted(content)
+    content_tag :i, "<#{ content }>", class: 'text-muted'
+  end
+end

data/lib/interfaces/wallaby/mode.rb

@@ -0,0 +1,18 @@
+class Wallaby::Mode
+  INTERFACE_METHODS = %w( model_decorator model_finder model_operator )
+
+  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
+        end
+      rescue NameError
+        fail Wallaby::NotImplemented, class_name
+      end
+    end
+  end
+end

data/lib/interfaces/wallaby/model_decorator.rb

@@ -0,0 +1,58 @@
+class Wallaby::ModelDecorator
+  attr_reader :model_class
+
+  def initialize(model_class)
+    @model_class = model_class
+  end
+
+  [ '', 'index_', 'show_', 'form_' ].each do |prefix|
+    class_eval <<-RUBY
+      def #{ prefix }fields
+        fail Wallaby::NotImplemented
+      end
+
+      def #{ prefix }fields=(#{ prefix }fields)
+        @#{ prefix }fields = #{ prefix }fields.with_indifferent_access
+      end
+
+      def #{ prefix }field_names
+        @#{ prefix }field_names ||= #{ prefix }fields.keys.tap do |names|
+          names.delete primary_key
+          names.unshift primary_key
+        end
+      end
+
+      def #{ prefix }field_names=(#{ prefix }field_names)
+        @#{ prefix }field_names = #{ prefix }field_names
+      end
+
+      def #{ prefix }metadata_of(field_name)
+        #{ prefix }fields[field_name] || {}
+      end
+
+      def #{ prefix }label_of(field_name)
+        #{ prefix }metadata_of(field_name)[:label]
+      end
+
+      def #{ prefix }type_of(field_name)
+        #{ prefix }metadata_of(field_name)[:type]
+      end
+    RUBY
+  end
+
+  def form_active_errors(resource)
+    fail Wallaby::NotImplemented
+  end
+
+  def primary_key
+    fail Wallaby::NotImplemented
+  end
+
+  def guess_title(resource)
+    fail Wallaby::NotImplemented
+  end
+
+  def resources_name
+    Wallaby::Utils.to_resources_name @model_class
+  end
+end

data/lib/interfaces/wallaby/model_finder.rb

@@ -0,0 +1,5 @@
+class Wallaby::ModelFinder
+  def all
+    fail Wallaby::NotImplemented
+  end
+end

data/lib/interfaces/wallaby/model_operator.rb

@@ -0,0 +1,31 @@
+class Wallaby::ModelOperator
+  def initialize(model_class, model_decorator = nil)
+    fail ArgumentError, 'model class required' unless model_class
+    @model_class      = model_class
+    @model_decorator  = model_decorator || Wallaby::DecoratorFinder.find_model(@model_class)
+  end
+
+  def collection(params, ability)
+    fail Wallaby::NotImplemented
+  end
+
+  def new(params)
+    fail Wallaby::NotImplemented
+  end
+
+  def find(id, params)
+    fail Wallaby::NotImplemented
+  end
+
+  def create(params, ability)
+    fail Wallaby::NotImplemented
+  end
+
+  def update(resource, params, ability)
+    fail Wallaby::NotImplemented
+  end
+
+  def destroy(resource, params)
+    fail Wallaby::NotImplemented
+  end
+end

data/lib/services/wallaby/decorator_finder.rb

@@ -0,0 +1,16 @@
+class Wallaby::DecoratorFinder
+  DEFAULT_DECORATOR = Wallaby::ResourceDecorator
+
+  def self.find_model(model_class)
+    Wallaby::Map.decorator_map[model_class] || new_model(model_class)
+  end
+
+  def self.find_resource(model_class)
+    Wallaby::Map.decorator_map[model_class] || DEFAULT_DECORATOR
+  end
+
+  def self.new_model(model_class)
+    mode = Wallaby::ActiveRecord
+    mode.model_decorator.new model_class
+  end
+end

data/lib/services/wallaby/lookup_context_wrapper.rb

@@ -0,0 +1,40 @@
+class Wallaby::LookupContextWrapper
+  delegate *begin # origin methods
+    ActionView::LookupContext.instance_methods \
+      - Object.instance_methods - %i( find_template )
+  end, to: :@lookup_context
+
+  def initialize(lookup_context)
+    @lookup_context = lookup_context
+  end
+
+  def find_template(*args)
+    key = args.join '/'
+    caching key do
+      @lookup_context.find_template *args
+    end
+  end
+
+  protected
+  def caching(key)
+    @templates ||= {}
+    unless @templates.has_key? key
+      @templates[key] = begin
+        yield
+      rescue ActionView::MissingTemplate
+        raise if Rails.env.development?
+        BlankTemplate.new
+      end
+    end
+    @templates[key]
+  end
+
+  class BlankTemplate < ActionView::Template::HTML
+    def initialize
+      super nil
+    end
+
+    def render(*args)
+    end
+  end
+end

data/lib/services/wallaby/map.rb

@@ -0,0 +1,53 @@
+class Wallaby::Map
+  def self.mode_map(modes = nil)
+    Rails.cache.fetch 'wallaby/map/mode_map' do
+      {}.tap do |map|
+        (modes || Wallaby::Mode.subclasses).each do |mode_class|
+          mode_class.model_finder.new.all.each do |model_class|
+            map[model_class] = mode_class
+          end
+        end
+      end
+    end
+  end
+
+  def self.model_classes(configuration = nil)
+    Rails.cache.fetch 'wallaby/map/model_classes' do
+      models          = (configuration || Wallaby.configuration).models
+      full_list       = mode_map.keys
+      configed_models = models.presence
+
+      return full_list - models.excludes unless configed_models
+
+      invalid_models = configed_models - full_list
+      if invalid_models.length > 0
+        fail Wallaby::InvalidError, "#{ invalid_models.to_sentence } are invalid models."
+      end
+      configed_models
+    end
+  end
+
+  def self.controller_map
+    model_class_map Wallaby::ResourcesController, __callee__
+  end
+
+  def self.decorator_map
+    model_class_map Wallaby::ResourceDecorator, __callee__
+  end
+
+  def self.servicer_map
+    model_class_map Wallaby::ModelServicer, __callee__
+  end
+
+  def self.model_class_map(base_class, method_id)
+    Rails.cache.fetch "wallaby/map/#{ method_id }" do
+      {}.tap do |map|
+        base_class.subclasses
+        .reject{ |klass| klass.name.blank? }
+        .each do |klass|
+          map[klass.model_class] = klass
+        end
+      end
+    end
+  end
+end

data/lib/services/wallaby/model_servicer.rb

@@ -0,0 +1,38 @@
+class Wallaby::ModelServicer
+  def self.model_class
+    if self < Wallaby::ModelServicer
+      Wallaby::Utils.to_model_class name.gsub('Servicer', ''), name
+    end
+  end
+
+  def initialize(model_class = nil, model_decorator = nil)
+    @model_class      = model_class || self.class.model_class
+    fail ArgumentError, 'model class required' unless @model_class
+    @model_decorator  = model_decorator || Wallaby::DecoratorFinder.find_model(@model_class)
+    @delegator        = Wallaby.adaptor.model_operator.new @model_class, @model_decorator
+  end
+
+  def collection(params, ability)
+    @delegator.collection params, ability
+  end
+
+  def new(params)
+    @delegator.new params
+  end
+
+  def find(id, params)
+    @delegator.find id, params
+  end
+
+  def create(params, ability)
+    @delegator.create params, ability
+  end
+
+  def update(resource, params, ability)
+    @delegator.update resource, params, ability
+  end
+
+  def destroy(resource, params)
+    @delegator.destroy resource, params
+  end
+end

data/lib/services/wallaby/servicer_finder.rb

@@ -0,0 +1,5 @@
+class Wallaby::ServicerFinder
+  def self.find(model_class)
+    Wallaby::Map.servicer_map[model_class] || Wallaby::ModelServicer
+  end
+end

data/lib/tasks/wallaby_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :wallaby do
+#   # Task goes here
+# end

data/lib/utils/wallaby/utils.rb

@@ -0,0 +1,31 @@
+module Wallaby::Utils
+  def self.to_resources_name(model_class)
+    return '' if model_class.blank?
+    model_class.to_s.underscore.gsub('/', '::').pluralize
+  end
+
+  def self.to_model_label(model_class)
+    model_class_name = to_model_name model_class
+    model_class_name.titleize.gsub '/', ' / '
+  end
+
+  def self.to_model_name(resources_name)
+    return '' if resources_name.blank?
+    resources_name.to_s.singularize.gsub('::', '/').camelize
+  end
+
+  def self.to_model_class(resources_name, source = nil)
+    return if resources_name.blank?
+    begin
+      class_name = to_model_name resources_name
+      class_name.constantize
+    rescue
+      message = [ class_name, source ].compact.join(' from ')
+      fail Wallaby::ModelNotFound, message
+    end
+  end
+
+  def self.to_hash(array)
+    Hash[ *array.flatten(1) ]
+  end
+end

data/lib/wallaby/configuration/models.rb

@@ -0,0 +1,17 @@
+class Wallaby::Configuration::Models
+  def set(models)
+    @models = Array models
+  end
+
+  def presence
+    @models.presence
+  end
+
+  def excludes
+    @excludes ||= []
+  end
+
+  def exclude(*models)
+    @excludes = models
+  end
+end

data/lib/wallaby/configuration/security.rb

@@ -0,0 +1,30 @@
+class Wallaby::Configuration::Security
+  # by default, current_user returns nil
+  DEFAULT_CURRENT_USER  = -> {}
+  # by default, authenticate returns true not to stop the before_action chain
+  DEFAULT_AUTHENTICATE  = -> { true }
+
+  def current_user(&block)
+    if block_given?
+      @current_user = block
+    else
+      @current_user ||= DEFAULT_CURRENT_USER
+    end
+  end
+
+  def current_user?
+    current_user != DEFAULT_CURRENT_USER
+  end
+
+  def authenticate(&block)
+    if block_given?
+      @authenticate = block
+    else
+      @authenticate ||= DEFAULT_AUTHENTICATE
+    end
+  end
+
+  def authenticate?
+    authenticate != DEFAULT_AUTHENTICATE
+  end
+end

data/lib/wallaby/configuration.rb

@@ -0,0 +1,49 @@
+module Wallaby
+  class Configuration
+    def adaptor
+      @adaptor ||= Wallaby::ActiveRecord
+    end
+
+    def adaptor=(adaptor)
+      if @adaptor
+        fail 'Adaptor has been initialized. Please place adaptor assignment at the top of configuration.'
+      end
+      @adaptor = adaptor
+    end
+
+    def models
+      @models ||= Models.new
+    end
+
+    def models=(models)
+      self.models.set models
+    end
+
+    def security
+      @security ||= Security.new
+    end
+
+    def base_controller
+      @base_controller ||= ::ApplicationController
+    end
+
+    def base_controller=(base_controller)
+      @base_controller = base_controller
+    end
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.config
+    yield configuration
+  end
+
+  def self.adaptor
+    configuration.adaptor
+  end
+end
+
+require 'wallaby/configuration/models'
+require 'wallaby/configuration/security'