aaf-lipstick 1.1.0 → 2.0.0

data/lib/aaf-lipstick.rb

@@ -1 +1,2 @@
+# frozen_string_literal: true
 require 'lipstick'

data/lib/lipstick.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Lipstick
   def self.asset_path
     File.expand_path(File.join('..', 'app', 'assets'), File.dirname(__FILE__))
@@ -7,6 +8,7 @@ end
 require 'lipstick/helpers'
 require 'lipstick/email_message'
 require 'lipstick/images'
-require 'lipstick/auto_validation'
+require 'lipstick/filterable' if defined?(Arel)
+require 'lipstick/auto_validation' if defined?(ActiveModel)
 require 'lipstick/engine' if defined?(Rails::Engine)
-require 'lipstick/action_view_tilt_template' if defined?(Tilt)
+require 'lipstick/version'

data/lib/lipstick/auto_validation.rb

@@ -1,12 +1,11 @@
-require 'active_model'
-
+# frozen_string_literal: true
 module Lipstick
   module AutoValidation
     module ClassMethods
       def self.extended(base)
         return if base.respond_to?(:validators)
 
-        fail('Lipstick::AutoValidation requires a class which responds' \
+        raise('Lipstick::AutoValidation requires a class which responds' \
              ' to the `validators` method. For example, as provided by' \
              ' ActiveModel::Validations')
       end
@@ -14,7 +13,7 @@ module Lipstick
       def lipstick_auto_validators
         validators.each_with_object({}) do |validator, map|
           validator.attributes.each do |attr|
-            out = semantic_ui_validator(attr, validator)
+            out = lipstick_validator(attr, validator)
             next if out.nil?
 
             map[attr.to_sym] ||= {}
@@ -23,46 +22,51 @@ module Lipstick
         end
       end
 
+      def lipstick_field_name(attr)
+        map = @lipstick_field_names || {}
+        return map[attr] if map.key?(attr)
+        attr.to_s.humanize(capitalize: false)
+      end
+
       private
 
       v = ActiveModel::Validations
       VALIDATOR_TRANSLATORS = {
-        v::PresenceValidator => :semantic_presence_validator,
-        v::LengthValidator => :semantic_length_validator,
-        v::NumericalityValidator => :semantic_numericality_validator
-      }
+        v::PresenceValidator => :lipstick_presence_validator,
+        v::LengthValidator => :lipstick_length_validator,
+        v::NumericalityValidator => :lipstick_numericality_validator
+      }.freeze
       private_constant :VALIDATOR_TRANSLATORS
 
-      def semantic_ui_validator(attr, validator)
+      def lipstick_validator(attr, validator)
         VALIDATOR_TRANSLATORS.each do |klass, sym|
           next unless validator.is_a?(klass)
-          return send(sym, attr, validator,
-                      attr.to_s.humanize(capitalize: false))
+          return send(sym, attr, validator, lipstick_field_name(attr.to_sym))
         end
         nil
       end
 
-      def semantic_presence_validator(_attr, _validator, humanized)
-        { empty: "Please enter a value for #{humanized}" }
+      def lipstick_presence_validator(_attr, _validator, humanized)
+        { required: { message: "Please enter a value for #{humanized}" } }
       end
 
-      def semantic_length_validator(_attr, validator, humanized)
+      def lipstick_length_validator(_attr, validator, humanized)
         min = validator.options[:minimum]
         max = validator.options[:maximum]
 
-        min_message = "Please enter a longer value for #{humanized}" \
-                      " (minimum #{min} characters)"
-        max_message = "Please enter a shorter value for #{humanized}" \
-                      " (maximum #{max} characters)"
+        min_message = "Please enter a longer value for #{humanized} " \
+                      "(minimum #{min} characters)"
+        max_message = "Please enter a shorter value for #{humanized} " \
+                      "(maximum #{max} characters)"
 
         {}.tap do |out|
-          out["length[#{min}]"] = min_message if min
-          out["maxLength[#{max}]"] = max_message if max
+          out[:minlength] = { param: min, message: min_message } if min
+          out[:maxlength] = { param: max, message: max_message } if max
         end
       end
 
-      def semantic_numericality_validator(_attr, _validator, humanized)
-        { integer: "Please enter a numeric value for #{humanized}" }
+      def lipstick_numericality_validator(_attr, _validator, humanized)
+        { digits: { message: "Please enter a numeric value for #{humanized}" } }
       end
     end
 

data/lib/lipstick/email_message.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'kramdown'
 require 'erubis'
 

data/lib/lipstick/engine.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
 module Lipstick
   class Engine < ::Rails::Engine
+    require 'active_support'
+    require 'active_support/core_ext/string/filters'
     isolate_namespace Lipstick
 
     initializer :assets do |app|

data/lib/lipstick/filterable.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Lipstick
+  module Filterable
+    # Provides case-insensitive matching on a case-sensitive MySQL database
+    # (which is mandated by Gumboot)
+    class CollatedArelAttribute < Arel::Nodes::Node
+      include Arel::Predications
+
+      attr_reader :attribute, :collation
+
+      def initialize(attribute, collation)
+        @attribute = attribute
+        @collation = collation
+      end
+    end
+
+    module VisitCollatedArelAttribute
+      # rubocop:disable Style/MethodName
+      def visit_Lipstick_Filterable_CollatedArelAttribute(o, collector)
+        visit(o.attribute, collector)
+        collector << ' COLLATE ' << o.collation
+      end
+      # rubocop:enable Style/MethodName
+    end
+
+    Arel::Visitors::ToSql.include(VisitCollatedArelAttribute)
+
+    module ClassMethods
+      attr_reader :filterable_fields
+
+      def filterable_by(*fields)
+        @filterable_fields = fields
+      end
+
+      def filter(query)
+        filter_terms(query).reduce(all) do |scope, term|
+          conds = filterable_fields.map do |f|
+            CollatedArelAttribute.new(arel_table[f], 'utf8_unicode_ci')
+                                 .matches(term)
+          end
+          scope.where(conds.reduce { |a, e| a.or(e) })
+        end
+      end
+
+      private
+
+      def filter_terms(query)
+        query.to_s.downcase.split(/\s+/).map { |s| "*#{s}*".gsub(/[%*]+/, '%') }
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/lipstick/helpers.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Lipstick
   module Helpers
   end
@@ -5,5 +6,8 @@ end
 
 require 'lipstick/helpers/layout_helper'
 require 'lipstick/helpers/nav_helper'
-require 'lipstick/helpers/semantic_form_builder'
-require 'lipstick/helpers/form_helper'
+require 'lipstick/helpers/form_validation_builder'
+require 'lipstick/helpers/bootstrap_form_builder' if defined?(ActionView)
+require 'lipstick/helpers/form_helper' if defined?(ActionView)
+require 'lipstick/helpers/pagination_link_renderer'
+require 'lipstick/helpers/compatibility_hacks'

data/lib/lipstick/helpers/bootstrap_form_builder.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+# rubocop:disable Metrics/ParameterLists
+
+class BootstrapFormBuilder < ActionView::Helpers::FormBuilder
+  attr_reader :template
+
+  def date_field(field, **opts)
+    add_css_class(opts, 'date-picker')
+    text_field(field, opts)
+  end
+
+  def text_field(field, **opts)
+    add_css_class(opts, 'form-control')
+    super
+  end
+
+  def password_field(field, **opts)
+    add_css_class(opts, 'form-control')
+    super
+  end
+
+  def text_area(method, **opts)
+    add_css_class(opts, 'form-control')
+    super
+  end
+
+  def check_box(*)
+    template.content_tag('div', class: 'checkbox') do
+      template.content_tag('label') do
+        template.concat(super)
+        template.concat(template.capture { yield })
+      end
+    end
+  end
+
+  def radio_button(*)
+    template.content_tag('div', class: 'radio') do
+      template.content_tag('label') do
+        template.concat(super)
+        template.concat(template.capture { yield })
+      end
+    end
+  end
+
+  def select(method, choices = nil, opts = {}, html_opts = {})
+    add_css_class(html_opts, 'form-control')
+    super
+  end
+
+  def collection_select(method, collection, value_method, text_method,
+                        opts = {}, html_opts = {})
+    add_css_class(html_opts, 'form-control')
+    super
+  end
+
+  private
+
+  def add_css_class(opts, class_name)
+    opts[:class] = "#{opts[:class]} #{class_name}".strip
+  end
+end

data/lib/lipstick/helpers/compatibility_hacks.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module Lipstick
+  module Helpers
+    module CompatibilityHacks
+      def concat(content)
+        @_out_buf << content
+      end
+
+      def content_tag(name, content_or_opts = nil, opts = nil, &block)
+        opts = content_or_opts if block_given?
+        content = block_given? ? capture(&block) : content_or_opts
+        "<#{name}#{html_attrs(opts)}>#{content}</#{name}>"
+      end
+
+      def tag(name, opts = nil)
+        "<#{name}#{html_attrs(opts)}/>"
+      end
+
+      def capture
+        old = @_out_buf
+        @_out_buf = io = StringIO.new
+        result = yield
+        io_length = io.length
+        io_length.positive? ? io.string : result
+      ensure
+        @_out_buf = old
+      end
+
+      private
+
+      def html_attrs(opts)
+        return '' if opts.nil?
+        opts.reduce('') do |a, (k, v)|
+          %(#{a} #{k}="#{v}")
+        end
+      end
+    end
+  end
+end

data/lib/lipstick/helpers/form_helper.rb

@@ -1,28 +1,69 @@
+# frozen_string_literal: true
 module Lipstick
   module Helpers
     module FormHelper
       include ActionView::Helpers::FormTagHelper
 
-      def field_block(html_opts = {}, &block)
-        if flag_enabled?(:inside_inline_form_tag)
-          html_opts[:class] = "#{html_opts[:class]} inline".strip
+      def field_block(html_opts = {})
+        add_css_class(html_opts, 'form-group')
+        content_tag('div', html_opts) { yield }
+      end
+
+      def radio_button_tag(name, value, checked = false, options = {})
+        content_tag('div', class: 'radio') do
+          content_tag('label') do
+            concat(super)
+            concat(capture { yield })
+          end
+        end
+      end
+
+      def check_box_tag(*)
+        content_tag('div', class: 'checkbox') do
+          content_tag('label') do
+            concat(super)
+            concat(capture { yield })
+          end
+        end
+      end
+
+      alias orig_form_tag form_tag
+
+      def inline_form_tag(url_for_options = {}, options = {})
+        add_css_class(options, 'form-inline')
+        form_tag(url_for_options, options) { yield }
+      end
+
+      def search_form_tag(filter, url: nil)
+        form_tag(url, method: :get) do
+          field_block { search_form_input_tag(filter) }
         end
+      end
 
-        html_opts[:class] = "#{html_opts[:class]} field".strip
-        content_tag('div', html_opts, &block)
+      def search_form_input_tag(filter)
+        content_tag('div', class: 'row') do
+          content_tag('div', grouped_search_field(filter), class: 'col-lg-12')
+        end
       end
 
-      alias_method :orig_form_tag, :form_tag
+      def search_filter_text_field(filter)
+        orig_text_field_tag(:filter, filter,
+                            placeholder: 'Search within these entries',
+                            autocomplete: 'off',
+                            class: 'form-control')
+      end
 
-      def form_tag(form_opts, html_opts = {}, &block)
-        html_opts[:class] = "#{html_opts[:class]} ui form".strip
-        orig_form_tag(form_opts, html_opts, &block)
+      def search_button
+        button_tag(type: 'submit') do
+          concat(icon_tag('search'))
+          concat(' Search')
+        end
       end
 
-      def inline_form_tag(form_opts, html_opts = {}, &block)
-        with_flag_enabled(:inside_inline_form_tag) do
-          html_opts[:class] = "#{html_opts[:class]} ui form inline-form".strip
-          orig_form_tag(form_opts, html_opts, &block)
+      def grouped_search_field(filter)
+        content_tag('div', class: 'input-group') do
+          concat(search_filter_text_field(filter))
+          concat(content_tag('span', search_button, class: 'input-group-btn'))
         end
       end
 
@@ -30,167 +71,107 @@ module Lipstick
         content_tag('div', style: 'display: none;', &block)
       end
 
-      def text_field_tag(*args)
-        content_tag('div', class: 'ui input') { super }
+      alias orig_text_field_tag text_field_tag
+
+      def text_field_tag(name, value = nil, opts = {})
+        add_css_class(opts, 'form-control')
+        super
       end
 
-      def field_help_text(text)
-        icon_tag('field-help-text blue help', 'data-content' => text)
+      def text_area_tag(name, content = nil, opts = {})
+        add_css_class(opts, 'form-control')
+        super
       end
 
-      def button_tag(content_or_options = nil, options = nil, &block)
-        add_class = ->(m) { m.dup.merge(class: "#{m[:class]} ui button".strip) }
+      def date_field_tag(name, value = nil, **opts)
+        opts[:class] = "#{opts[:class]} date-picker".strip
+        text_field_tag(name, value, opts)
+      end
+
+      def select_tag(name, option_tags = nil, **opts)
+        add_css_class(opts, 'form-control')
+        super
+      end
 
+      def button_tag(content_or_options = nil, options = nil, &block)
         if content_or_options.is_a?(Hash)
-          super(add_class.call(content_or_options), &block)
+          content_or_options[:class] ||= 'btn-default'
+          add_css_class(content_or_options, 'btn')
+          super
         else
-          super(content_or_options, add_class.call(options || {}), &block)
+          options ||= {}
+          options[:class] ||= 'btn-default'
+          add_css_class(options, 'btn')
+          super(content_or_options, options, &block)
         end
       end
 
       def delete_button_tag(url, text: true, **opts)
-        css_class = 'ui tiny red icon delete button floating dropdown'
-        content_tag('div', class: "#{css_class} #{opts[:class]}".strip) do
-          concat(icon_tag('trash'))
-          action = text && text.is_a?(String) ? text : 'Delete'
-          concat(action) if text
-          confirm = button_link_to(url, method: :delete, class: 'small') do
-            "Confirm #{action}"
-          end
-          concat(content_tag('div', confirm, class: 'menu'))
-        end
-      end
-
-      def error_messages_tag
-        content_tag('div', '', class: 'ui error message')
-      end
+        action = text && text.is_a?(String) ? text : 'Delete'
 
-      def radio_button_tag(name, value, checked = false, options = {}, &block)
-        field_block do
-          content_tag('div', class: 'ui radio checkbox') do
-            concat(super)
-            concat(capture(&block))
-          end
+        content_tag('div', class: 'btn-group') do
+          concat(delete_dropdown_opener(text && action, opts))
+          concat(confirm_delete_dropdown(url, action))
         end
       end
 
       def form_for(obj, opts = {}, &block)
-        opts[:builder] = SemanticFormBuilder
-        opts[:html] ||= {}
-        opts[:html][:class] = "#{opts[:html][:class]} ui form".strip
+        opts[:builder] = BootstrapFormBuilder
         super(obj, opts, &block)
       end
 
-      def radio_button_block(&block)
-        content_tag('div', class: 'grouped fields', &block)
-      end
-
       # Generates the wrapping code for validating a form. The selector is
       # passed to jQuery, and must uniquely select the form being validated.
       # `sym` is the object name when using a `form_for` helper to generate the
       # form.
       #
       # e.g.
-      # <%= validate_form('#new-test-object', :test_object) do -%>
-      #   <%= validate_field(:name, ...) %> Validate the test_object[name] field
-      # <%- end -%>
-      def validate_form(selector, sym = nil, &block)
-        content_tag('script', type: 'text/javascript') do
-          jquery_callback(validation_body(selector, sym, &block)).html_safe
-        end
-      end
-
-      # Generates a validator for a field. `opts` is a Hash containing the
-      # `type` and `prompt` for each desired validation per Semantic UI:
-      # http://semantic-ui.com/modules/form.html
-      #
-      # e.g.
-      # <%= validate_field(:email, email: 'Enter a valid email address') %>
-      # <%= validate_field(:password, :'length[6]' => '6 characters minimum') %>
-      # <%= validate_field(:multiple, empty: 'Not empty', url: 'Must be URL') %>
-      def validate_field(name, opts)
-        format('validations[%{name}] = ' \
-              '(function(v) { %{inner} })' \
-              '($.extend({rules: []}, validations[%{name}]));',
-               name: name.to_json,
-               inner: validation_for_field(name, opts)).html_safe
-      end
-
-      # Automatically generates validators for fields based on certain supported
-      # validators from ActiveModel::Validations. The model must include the
-      # Lipstick::AutoValidation module.
-      #
-      # class MyModel < ActiveRecord::Base
-      #   include Lipstick::AutoValidation
-      #
-      #   validates :name, presence: true
-      #   validates :description, length: 1..255
-      # end
-      #
-      # <%= auto_validate(@object, :name, :description) %>
-      def auto_validate(obj, *fields)
-        unless obj.class.respond_to?(:lipstick_auto_validators)
-          fail("#{obj.class.name} does not include Lipstick::AutoValidation")
-        end
-
-        validators = obj.class.lipstick_auto_validators
-        capture do
-          validators.slice(*fields).each do |name, opts|
-            concat validate_field(name, opts)
-          end
+      # <%=
+      #   validate_form('#new-test-object', :test_object) do |v|
+      #     v.validate_field(:name, ...) # Validate the test_object[name] field
+      #   end
+      # %>
+      def validate_form(selector, sym = nil)
+        opts = {
+          type: 'application/vnd.aaf.lipstick.validations+json',
+          'data-target': selector,
+          class: 'lipstick-validations'
+        }
+
+        content_tag('script', opts) do
+          validation_json(sym) { |v| yield v }.html_safe
         end
       end
 
       private
 
-      def validation_body(selector, sym, &block)
-        'var validations = {};' +
-          validation_name_mapping_function(sym) +
-          capture(&block) +
-          validation_install(selector)
+      def validation_json(sym)
+        v = FormValidationBuilder.new(sym)
+        yield v
+        JSON.generate(v.to_h)
       end
 
-      # When we're using form_for, we need to map ObjectType#name to a field
-      # named like: 'object_type[name]'
-      # Otherwise, we just use the name directly.
-      def validation_name_mapping_function(sym)
-        if sym.nil?
-          'var map_name = function(n) { return n; };'
-        else
-          'var map_name = function(n) { ' \
-            "return #{sym.to_json} + '[' + n + ']';" \
-          '};'
-        end
-      end
+      def delete_dropdown_opener(label, **opts)
+        opts = { 'aria-expanded': 'false', 'data-toggle': 'dropdown',
+                 type: 'button', 'aria-haspopup': 'true' }.merge(opts)
 
-      def validation_install(selector)
-        format('$(%s).form(validations, { keyboardShortcuts: false });',
-               selector.to_json)
-      end
-
-      def jquery_callback(body)
-        format('jQuery(function($){%s});', body)
-      end
+        add_css_class(opts, 'btn-small btn-danger dropdown-toggle')
 
-      def validation_for_field(name, opts)
-        rules = opts.map { |t, m| { type: t, prompt: m } }
-        "v.rules = v.rules.concat(#{rules.to_json});" \
-          "v.identifier = map_name(#{name.to_json});" \
-          'return v;'
+        button_tag(opts) do
+          concat(icon_tag('trash'))
+          concat(' ')
+          concat(label)
+        end
       end
 
-      def with_flag_enabled(flag)
-        old = Thread.current[flag]
-        begin
-          Thread.current[flag] = true
-          yield
-        ensure
-          Thread.current[flag] = old
-        end
+      def confirm_delete_dropdown(url, action)
+        link = link_to("Confirm #{action}", url, class: 'confirm-delete')
+        item = content_tag('li', link)
+        content_tag('ul', item, class: 'dropdown-menu')
       end
 
-      def flag_enabled?(flag)
-        Thread.current[flag]
+      def add_css_class(opts, class_name)
+        opts[:class] = "#{opts[:class]} #{class_name}".strip
       end
     end
   end