wallaby 4.1.6

data/lib/adaptors/wallaby/active_record/model_decorator.rb

@@ -0,0 +1,81 @@
+class Wallaby::ActiveRecord::ModelDecorator < Wallaby::ModelDecorator
+  def fields
+    @fields ||= {}.tap do |hash|
+      if model_class.table_exists?
+        hash.merge! general_fields
+        hash.merge! association_fields
+        hash.except! *foreign_keys_from_associations
+      end
+    end.with_indifferent_access
+  end
+
+  def index_fields
+    @index_fields ||= fields.deep_dup
+  end
+
+  def show_fields
+    @show_fields  ||= fields.deep_dup
+  end
+
+  def form_fields
+    @form_fields  ||= fields.deep_dup
+  end
+
+  def index_field_names
+    @index_field_names ||= index_fields.reject do |field_name, metadata|
+      metadata[:is_association] ||
+      %w( binary citext hstore json jsonb text tsvector xml ).include?(metadata[:type])
+    end.keys
+  end
+
+  def form_field_names
+    @form_field_names ||= form_fields.reject do |field_name, metadata|
+      %W( #{ primary_key } updated_at created_at ).include?(field_name) ||
+      metadata[:has_scope] ||
+      metadata[:is_through]
+    end.keys
+  end
+
+  def form_active_errors(resource)
+    resource.errors
+  end
+
+  def primary_key
+    @model_class.primary_key
+  end
+
+  def guess_title(resource)
+    resource.public_send title_field_finder.find
+  end
+
+  protected
+  def field_builder
+    @field_builder ||= Wallaby::ActiveRecord::ModelDecorator::FieldsBuilder.new @model_class
+  end
+
+  def title_field_finder
+    @title_field_finder ||= Wallaby::ActiveRecord::ModelDecorator::TitleFieldFinder.new @model_class, general_fields
+  end
+
+  delegate :general_fields, :association_fields, to: :field_builder
+
+  def foreign_keys_from_associations(associations = association_fields)
+    associations.inject([]) do |keys, (field_name, metadata)|
+      keys << metadata[:foreign_key]      if metadata[:foreign_key]
+      keys << metadata[:polymorphic_type] if metadata[:polymorphic_type]
+      keys
+    end
+  end
+
+  def many_associations(associations = association_fields)
+    associations.select do |field_name, metadata|
+      /many/ =~ metadata[:type] && !metadata[:is_through]
+    end
+  end
+
+  def belongs_to_associations(associations = association_fields)
+    associations.select do |field_name, metadata|
+      'belongs_to' == metadata[:type]
+    end
+  end
+end

data/lib/adaptors/wallaby/active_record/model_finder.rb

@@ -0,0 +1,12 @@
+class Wallaby::ActiveRecord::ModelFinder < Wallaby::ModelFinder
+  def all
+    Rails.cache.fetch 'wallaby/active_record/model_finder' do
+      ActiveRecord::Base.subclasses.reject do |model_class|
+        model_class.abstract_class? ||
+        model_class.to_s.start_with?('#<') ||
+        model_class.name == 'ActiveRecord::SchemaMigration' ||
+        model_class.name.index('HABTM')
+      end.sort_by &:to_s
+    end
+  end
+end

data/lib/adaptors/wallaby/active_record/model_operator/normalizer.rb

@@ -0,0 +1,44 @@
+class Wallaby::ActiveRecord::ModelOperator::Normalizer
+  def initialize(model_decorator)
+    @model_decorator = model_decorator
+  end
+
+  def normalize(params)
+    params.each do |field_name, values|
+      next unless metadata = @model_decorator.fields[field_name]
+
+      case metadata[:type]
+      when /range/
+        normalize_range_values params, field_name, values
+      when /point/
+        normalize_point_values params, field_name, values
+      when /binary/
+        normalize_binary_values params, field_name, values
+      end
+    end
+  end
+
+  def normalize_range_values(params, field_name, values)
+    normalized = Array(values).map(&:presence).compact
+    if normalized.length > 0 && values.length == 2
+      params[field_name] = values.first...values.last
+    else
+      params[field_name] = nil
+    end
+  end
+
+  def normalize_point_values(params, field_name, values)
+    normalized = Array(values).map(&:presence).compact
+    if normalized.length > 0
+      params[field_name] = values.map &:to_f
+    else
+      params[field_name] = nil
+    end
+  end
+
+  def normalize_binary_values(params, field_name, values)
+    if values.is_a?(ActionDispatch::Http::UploadedFile)
+      params[field_name] = values.read
+    end
+  end
+end

data/lib/adaptors/wallaby/active_record/model_operator/permitter.rb

@@ -0,0 +1,50 @@
+class Wallaby::ActiveRecord::ModelOperator::Permitter
+  def initialize(model_decorator)
+    @model_decorator = model_decorator
+  end
+
+  def simple_field_names
+    field_names = non_range_fields.keys + belongs_to_fields.map do |_, metadata|
+      [ metadata[:foreign_key], metadata[:polymorphic_type] ]
+    end.flatten.compact
+    field_names.reject do |field_name|
+      [ @model_decorator.primary_key, 'created_at', 'updated_at' ].include? field_name
+    end
+  end
+
+  def compound_hashed_fields
+    field_names = range_fields.keys + many_association_fields.map{ |_, metadata| metadata[:foreign_key] }
+    Wallaby::Utils.to_hash(field_names.map{ |field_name| [ field_name, [] ] })
+  end
+
+  protected
+  def non_association_fields
+    @model_decorator.fields.select{ |_, metadata| !metadata[:is_association] }
+  end
+
+  def non_range_fields
+    non_association_fields.select{ |_, metadata| !(/range|point/ =~ metadata[:type]) }
+  end
+
+  def range_fields
+    non_association_fields.select do |_, metadata|
+      /range|point/ =~ metadata[:type]
+    end
+  end
+
+  def association_fields
+    @model_decorator.fields.select do |_, metadata|
+      metadata[:is_association] && !metadata[:has_scope] && !metadata[:is_through]
+    end
+  end
+
+  def many_association_fields
+    association_fields.select{ |_, metadata| /many/ =~ metadata[:type] }
+  end
+
+  def belongs_to_fields
+    association_fields.select do |field_name, metadata|
+      'belongs_to' == metadata[:type]
+    end
+  end
+end

data/lib/adaptors/wallaby/active_record/model_operator/querier.rb

@@ -0,0 +1,47 @@
+class Wallaby::ActiveRecord::ModelOperator::Querier
+  def initialize(model_decorator)
+    @model_decorator  = model_decorator
+    @model_class      = @model_decorator.model_class
+  end
+
+  def search(params)
+    text_keywords, field_keywords = extract params
+    query = @model_class.where nil
+    query = text_search text_keywords, query
+    query = field_search field_keywords, query
+    query
+  end
+
+  protected
+  def extract(params)
+    all_keywords = (params[:q] || '').split(' ').compact
+    field_keywords = all_keywords.select{ |v| v.split(':').length == 2 }
+    [ all_keywords - field_keywords, field_keywords ]
+  end
+
+  def text_search(keywords, query)
+    return query if keywords.blank?
+
+    queries = text_fields.inject([]) do |queries, field_name|
+      likes = keywords.map do |keyword|
+        [ "UPPER(#{ field_name }) LIKE ?", "%#{ keyword.upcase }%" ]
+      end
+      queries << [ "(#{ likes.map(&:first).join ' AND ' })", likes.map(&:last) ]
+    end
+    query.where queries.map(&:first).join(' OR '), *queries.map(&:last).flatten
+  end
+
+  def field_search(keywords, query)
+    return query if keywords.blank?
+
+    hashed_queries = Wallaby::Utils.to_hash(keywords.map{ |v| v.split ':' })
+    query.where hashed_queries
+  end
+
+  def text_fields
+    @model_decorator.fields.select do |field_name, metadata|
+      @model_decorator.index_field_names.include?(field_name) &&
+      %w( string text citext ).include?(metadata[:type])
+    end.keys
+  end
+end

data/lib/adaptors/wallaby/active_record/model_operator/validator.rb

@@ -0,0 +1,16 @@
+class Wallaby::ActiveRecord::ModelOperator::Validator
+  def initialize(model_decorator)
+    @model_decorator = model_decorator
+  end
+
+  def valid?(resource)
+    resource.attributes.each do |field_name, values|
+      next unless metadata = @model_decorator.fields[field_name]
+      if %w( daterange tsrange tstzrange ).include?(metadata[:type]) &&
+        values.try(:any?, &:blank?)
+        resource.errors.add field_name, 'required for range data'
+      end
+    end
+    resource.errors.blank?
+  end
+end

data/lib/adaptors/wallaby/active_record/model_operator.rb

@@ -0,0 +1,82 @@
+class Wallaby::ActiveRecord::ModelOperator < Wallaby::ModelOperator
+  def collection(params, ability)
+    query = querier.search params
+    query = query.order params[:sort] if params[:sort].present?
+    query.accessible_by ability
+  end
+
+  def new(params)
+    permitted = permit params rescue {}
+    @model_class.new permitted
+  end
+
+  def find(id, params)
+    @model_class.find id
+  rescue ActiveRecord::RecordNotFound
+    fail Wallaby::ResourceNotFound
+  end
+
+  def create(params, ability)
+    resource = @model_class.new
+    resource.assign_attributes normalize permit(params)
+    ensure_attributes_for ability, :create, resource
+    resource.save if valid? resource
+    [ resource, resource.errors.blank? ]
+  rescue ActiveRecord::StatementInvalid => e
+    resource.errors.add :base, e.message
+    [ resource, false ]
+  end
+
+  def update(resource, params, ability)
+    resource.assign_attributes normalize permit(params)
+    ensure_attributes_for ability, :update, resource
+    resource.save if valid? resource
+    [ resource, resource.errors.blank? ]
+  rescue ActiveRecord::StatementInvalid => e
+    resource.errors.add :base, e.message
+    [ resource, false ]
+  end
+
+  def destroy(resource, params)
+    resource.destroy
+  end
+
+  protected
+  def permit(params)
+    params.require(param_key).permit(permitter.simple_field_names << permitter.compound_hashed_fields)
+  end
+
+  def normalize(params)
+    normalizer.normalize params
+  end
+
+  def valid?(resource)
+    validator.valid? resource
+  end
+
+  def ensure_attributes_for(ability, action, resource)
+    return if ability.blank?
+    restricted_conditions = ability.attributes_for action, resource
+    resource.assign_attributes restricted_conditions
+  end
+
+  def param_key
+    @model_class.model_name.param_key
+  end
+
+  def permitter
+    @permitter ||= Wallaby::ActiveRecord::ModelOperator::Permitter.new @model_decorator
+  end
+
+  def querier
+    @querier ||= Wallaby::ActiveRecord::ModelOperator::Querier.new @model_decorator
+  end
+
+  def normalizer
+    @normalizer ||= Wallaby::ActiveRecord::ModelOperator::Normalizer.new @model_decorator
+  end
+
+  def validator
+    @validator ||= Wallaby::ActiveRecord::ModelOperator::Validator.new @model_decorator
+  end
+end

data/lib/adaptors/wallaby/active_record.rb

@@ -0,0 +1,2 @@
+class Wallaby::ActiveRecord < Wallaby::Mode
+end

data/lib/decorators/wallaby/resource_decorator.rb

@@ -0,0 +1,78 @@
+class Wallaby::ResourceDecorator
+  class << self
+    def model_class
+      if self < Wallaby::ResourceDecorator
+        @model_class ||= Wallaby::Utils.to_model_class name.gsub('Decorator', ''), name
+      end
+    end
+
+    def model_decorator
+      if self < Wallaby::ResourceDecorator
+        @model_decorator ||= Wallaby::DecoratorFinder.new_model model_class
+      end
+    end
+
+    def decorate(resource)
+      return resource if resource.is_a? Wallaby::ResourceDecorator
+      new resource
+    end
+
+    delegate *begin
+      Wallaby::ModelDecorator.instance_methods \
+        - Object.instance_methods - %i( model_class )
+    end, to: :model_decorator, allow_nil: true
+  end
+
+  def initialize(resource)
+    @resource         = resource
+    @model_decorator  = self.class.model_decorator || Wallaby::DecoratorFinder.new_model(model_class)
+  end
+
+  def method_missing(method_id, *args)
+    if @resource.respond_to? method_id
+      @resource.public_send method_id, *args
+    else
+      super
+    end
+  end
+
+  delegate :to_s, :to_param, :to_params, to: :@resource
+  delegate *begin
+    Wallaby::ModelDecorator.instance_methods \
+      - %i( index_fields index_field_names show_fields show_field_names form_fields form_field_names ) \
+      - Object.instance_methods
+  end, to: :@model_decorator
+  attr_reader :model_decorator
+
+  def model_class
+    @resource.class
+  end
+
+  def resource
+    @resource
+  end
+
+  def to_label
+    @model_decorator.guess_title(@resource) || primary_key_value
+  end
+
+  def errors
+    @model_decorator.form_active_errors(@resource)
+  end
+
+  def primary_key_value
+    @resource.public_send primary_key
+  end
+
+  [ '', 'index_', 'show_', 'form_' ].each do |prefix|
+    class_eval <<-RUBY
+      def #{ prefix }fields
+        @#{ prefix }fields ||= @model_decorator.#{ prefix }fields.dup.freeze
+      end
+
+      def #{ prefix }field_names
+        @#{ prefix }field_names ||= @model_decorator.#{ prefix }field_names.dup.freeze
+      end
+    RUBY
+  end
+end

data/lib/errors/wallaby/deprecated.rb

@@ -0,0 +1,4 @@
+module Wallaby
+  class Deprecated < GeneralError
+  end
+end

data/lib/errors/wallaby/general_error.rb

@@ -0,0 +1,4 @@
+module Wallaby
+  class GeneralError < ::StandardError
+  end
+end

data/lib/errors/wallaby/invalid_error.rb

@@ -0,0 +1,4 @@
+module Wallaby
+  class InvalidError < ::StandardError
+  end
+end

data/lib/errors/wallaby/model_not_found.rb

@@ -0,0 +1,4 @@
+module Wallaby
+  class ModelNotFound < GeneralError
+  end
+end

data/lib/errors/wallaby/not_authenticated.rb

@@ -0,0 +1,4 @@
+module Wallaby
+  class NotAuthenticated < GeneralError
+  end
+end

data/lib/errors/wallaby/not_implemented.rb

@@ -0,0 +1,4 @@
+module Wallaby
+  class NotImplemented < GeneralError
+  end
+end

data/lib/errors/wallaby/operation_not_found.rb

@@ -0,0 +1,4 @@
+module Wallaby
+  class OperationNotFound < GeneralError
+  end
+end

data/lib/errors/wallaby/resource_not_found.rb

@@ -0,0 +1,4 @@
+module Wallaby
+  class ResourceNotFound < GeneralError
+  end
+end

data/lib/forms/wallaby/form_builder.rb

@@ -0,0 +1,30 @@
+class Wallaby::FormBuilder < ActionView::Helpers::FormBuilder
+  def error_class(field_name)
+    'has-error' if has_error? field_name
+  end
+
+  def error_messages(field_name)
+    errors = Array object.errors[ field_name ]
+    return if errors.blank?
+
+    content_tag :ul, class: 'text-danger' do
+      errors.each do |message|
+        concat content_tag :li, content_tag(:small, raw(message))
+      end
+    end
+  end
+
+  protected
+  def method_missing(method, *args, &block)
+    if @template.respond_to? method
+      self.class.delegate method, to: :@template
+      @template.public_send method, *args, &block
+    else
+      super
+    end
+  end
+
+  def has_error?(field_name)
+    object.errors[field_name].present?
+  end
+end

data/lib/handlers/wallaby/cached_compiled_erb.rb

@@ -0,0 +1,14 @@
+require 'erubis'
+
+# TODO: move this kind of logic into a gem called faster rails :)
+class Wallaby::CachedCompiledErb < ActionView::Template::Handlers::ERB
+  def call(template)
+    if Rails.env.development?
+      super
+    else
+      Rails.cache.fetch "wallaby/views/erb/#{ template.inspect }" do
+        super
+      end
+    end
+  end
+end

data/lib/helpers/wallaby/application_helper.rb

@@ -0,0 +1,30 @@
+module Wallaby::ApplicationHelper
+  def clean_params
+    params.except :resources, :action
+  end
+
+  # override `actionview/lib/action_view/routing_url_for.rb#url_for`
+  def url_for(options = nil)
+    if options.is_a?(Hash) && options.slice(:action, :resources).length == 2
+      return wallaby_resourceful_url_for options
+    end
+    super
+  end
+
+  def wallaby_resourceful_url_for(options = {})
+    # DEPRECATION WARNING: You are calling a `*_path` helper with the `only_path` option explicitly set to `false`. This option will stop working on path helpers in Rails 5. Use the corresponding `*_url` helper instead.
+    options = options.except :only_path
+    case options[:action]
+    when 'index', 'create'
+      wallaby_engine.resources_path options
+    when 'new'
+      wallaby_engine.new_resource_path options
+    when 'edit'
+      wallaby_engine.edit_resource_path options
+    when 'show', 'update', 'destroy'
+      wallaby_engine.resource_path options
+    else
+      wallaby_engine.url_for options
+    end
+  end
+end

data/lib/helpers/wallaby/core_helper.rb

@@ -0,0 +1,50 @@
+require 'securerandom'
+
+# NOTE: Global helper methods should go in here
+module Wallaby::CoreHelper
+  include Wallaby::StylingHelper
+  include Wallaby::LinksHelper
+
+  def to_model_label(model_class)
+    Wallaby::Utils.to_model_label model_class
+  end
+
+  def to_resources_name(model_class)
+    Wallaby::Utils.to_resources_name model_class
+  end
+
+  def current_model_label
+    if current_resources_name.present?
+      label = to_model_label current_resources_name
+      return "Resource: #{ label }" if label.present?
+    end
+    'Resources'
+  end
+
+  def body_class
+    [
+      params[:action],
+      current_resources_name.try(:gsub, '::', '__'),
+      content_for(:custom_body_class)
+    ].compact.join ' '
+  end
+
+  def page_title
+    'Wallaby::Admin'
+  end
+
+  def ct(key, options = {})
+    t key, { raise: true }.merge(options)
+  rescue I18n::MissingTranslationData => e
+    keys = I18n.normalize_keys(e.locale, e.key, e.options[:scope])
+    keys.last.to_s.titleize
+  end
+
+  def random_uuid
+    SecureRandom.uuid
+  end
+
+  def model_classes
+    Wallaby::Map.model_classes.sort_by &:name
+  end
+end

data/lib/helpers/wallaby/form_helper.rb

@@ -0,0 +1,21 @@
+module Wallaby::FormHelper
+  def form_type_partial_render(options = {}, locals = {}, &block)
+    form        = locals[:form]
+    field_name  = locals[:field_name].to_s
+
+    fail ArgumentError unless form.present? && field_name.present? && form.object.is_a?(Wallaby::ResourceDecorator)
+
+    locals[:object]   = object = form.object
+    locals[:metadata] = object.form_metadata_of locals[:field_name]
+    locals[:value]    = object.public_send locals[:field_name]
+
+    render(options, locals, &block) or render('string', locals, &block)
+  end
+
+  def model_choices(model_decorator)
+    collection = model_servicer(model_decorator).collection Hash.new, current_ability
+    decorate(collection).map do |decorated|
+      [ decorated.to_label, decorated.primary_key_value ]
+    end
+  end
+end