aaf-lipstick 1.1.0 → 2.0.0

data/lib/lipstick/helpers/form_validation_builder.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+module Lipstick
+  module Helpers
+    class FormValidationBuilder
+      def initialize(sym)
+        @rules = {}
+        @messages = {}
+        @sym = sym
+      end
+
+      def to_h
+        { rules: @rules, messages: @messages }
+      end
+
+      def validate_field(field, opts)
+        target = wrap_name(field)
+
+        opts.each do |k, v|
+          next validate_with_hash(target, k, v) if v.is_a?(Hash)
+          validate_with_param(target, k, v)
+        end
+      end
+
+      def auto_validate(obj, *fields)
+        unless obj.class.respond_to?(:lipstick_auto_validators)
+          raise("#{obj.class.name} does not include Lipstick::AutoValidation")
+        end
+
+        validators = obj.class.lipstick_auto_validators
+        validators.slice(*fields).each do |field, opts|
+          validate_field(field, opts)
+        end
+      end
+
+      private
+
+      def validate_with_hash(target, validation, opts)
+        message = opts.delete(:message)
+        add_message(target, validation, message) if message
+
+        return validate_with_param(target, validation, true) if opts.empty?
+
+        if opts.keys == [:param]
+          return validate_with_param(target, validation, opts[:param])
+        end
+
+        add_rule(target, validation, opts)
+      end
+
+      def validate_with_param(target, validation, param)
+        add_rule(target, validation, param)
+      end
+
+      def add_rule(target, key, value)
+        @rules[target] ||= {}
+        @rules[target][key] = value
+      end
+
+      def add_message(target, key, value)
+        @messages[target] ||= {}
+        @messages[target][key] = value
+      end
+
+      def wrap_name(name)
+        return name if @sym.nil?
+        "#{@sym}[#{name}]"
+      end
+    end
+  end
+end

data/lib/lipstick/helpers/layout_helper.rb

@@ -1,23 +1,20 @@
-require 'action_view'
-
+# frozen_string_literal: true
 module Lipstick
   module Helpers
     module LayoutHelper
-      include ActionView::Helpers::TagHelper
-      include ActionView::Helpers::TextHelper
-      include ActionView::Helpers::CaptureHelper
-
-      def aaf_header(title:, environment: nil, &bl)
+      def aaf_header(title:, environment: nil, auth: nil, &bl)
         content_tag('div', class: 'aaf-header') do
-          concat(aaf_banner(title, environment))
+          concat(aaf_banner(title, environment, auth))
           concat(capture(&bl))
         end
       end
 
-      def aaf_footer(&bl)
+      def aaf_footer
         content_tag('footer') do
-          concat(content_tag('div', '', class: 'ui divider'))
-          concat(capture(&bl))
+          content_tag('div', class: 'footer-content') do
+            concat(aaf_logo)
+            concat(capture { yield })
+          end
         end
       end
 
@@ -31,25 +28,23 @@ module Lipstick
       end
 
       def page_header(header, subheader = nil)
-        content_tag('h2', class: 'ui header') do
-          concat(header)
-          if subheader
-            concat(content_tag('div', subheader, class: 'sub header'))
+        content_tag('div', class: 'page-header') do
+          content_tag('h1') do
+            concat(header)
+            concat(' ')
+            concat(content_tag('small', subheader)) if subheader
           end
         end
       end
 
-      def divider_tag
-        content_tag('div', '', class: 'ui divider')
-      end
-
       def yes_no_string(boolean)
         boolean ? 'Yes' : 'No'
       end
 
       def icon_tag(icon_class, html_opts = {})
-        html_opts[:class] = "#{html_opts[:class]} icon #{icon_class}".strip
-        content_tag('i', '', html_opts)
+        html_opts[:class] =
+          "#{html_opts[:class]} glyphicon glyphicon-#{icon_class}".strip
+        content_tag('span', '', html_opts)
       end
 
       # button_link_to(url_opts) { 'Link Text' }
@@ -60,77 +55,123 @@ module Lipstick
         args.unshift(capture(&block)) if block_given?
         text, url_opts, html_opts = args
         html_opts ||= {}
-        html_opts[:class] = "#{html_opts[:class]} ui button".strip
+        html_opts[:class] ||= 'btn-default'
+        html_opts[:class] = "#{html_opts[:class]} btn".strip
         link_to(text, url_opts, html_opts)
       end
 
       def info_message(title, &block)
-        message_block(title, 'info', 'info', &block)
+        alert_block(title, 'info', &block)
       end
 
       def error_message(title, &block)
-        message_block(title, 'error', 'warning', &block)
+        alert_block(title, 'danger', &block)
       end
 
       def success_message(title, &block)
-        message_block(title, 'success', 'smile', &block)
+        alert_block(title, 'success', &block)
       end
 
       def warning_message(title, &block)
-        message_block(title, 'warning', 'warning', &block)
+        alert_block(title, 'warning', &block)
       end
 
       def breadcrumbs(*links)
-        content_tag('div', class: 'ui breadcrumb') do
+        content_tag('ol', class: 'breadcrumb') do
           last = links.pop
 
           links.each do |link|
-            concat(content_tag('div', breadcrumb_link(link), class: 'section'))
-            concat(icon_tag('angle double right divider'))
+            concat(content_tag('li', breadcrumb_link(link)))
           end
 
-          concat(content_tag('div', breadcrumb_link(last),
-                             class: 'active section'))
+          concat(content_tag('li', breadcrumb_link(last),
+                             class: 'active'))
         end
       end
 
+      def will_paginate(_ = nil, options = {})
+        options[:renderer] ||= Lipstick::Helpers::PaginationLinkRenderer
+        super
+      end
+
+      DISABLE_ANIMATIONS_CSS = <<-EOF
+        .ui, .ui * {
+          -webkit-animation-duration: 0ms !important;
+          -moz-animation-duration: 0ms !important;
+          -ms-animation-duration: 0ms !important;
+          animation-duration: 0ms !important;
+        }
+      EOF
+      private_constant :DISABLE_ANIMATIONS_CSS
+
+      def disable_animations
+        content_tag('style', DISABLE_ANIMATIONS_CSS, type: 'text/css')
+      end
+
       private
 
-      def aaf_banner(title, environment)
-        content_tag('header', class: 'banner clearfix') do
-          concat(aaf_environment_string(environment))
-          header = content_tag('h2', class: 'ui inverted header') do
-            # The logo width is also forced in CSS. The logo is scaled to 50% in
-            # both width and height to improve quality on high-density displays.
-            concat(tag('img', src: image_path('logo.png'), class: 'logo',
-                              width: 138, height: 80))
-            concat(content_tag('div', title, class: 'content'))
+      def aaf_banner(title, environment, auth)
+        capture do
+          text = content_tag('header') do
+            concat(aaf_links(auth))
+            concat(title)
+            concat(aaf_environment_string(environment))
           end
-          concat(header)
+          concat(text)
         end
       end
 
-      def aaf_environment_string(environment)
-        return if environment.nil?
-        content_tag('div', environment, class: 'environment')
+      def aaf_logo
+        content_tag('span', '', class: 'pull-right logo hidden-xs hidden-sm')
       end
 
-      def image_path(*)
-        unless defined?(super)
-          fail('No image_path method was found. This is typically provided by' \
-               ' Rails or Sprockets::Helpers')
+      def aaf_links(auth)
+        content_tag('div', class: 'aaf-links pull-right') do
+          concat(aaf_home_link)
+          concat(aaf_support_link)
+          concat(aaf_auth_link(auth))
         end
-        super
       end
 
-      def message_block(title, color_class, icon_class, &block)
-        content_tag('div', class: "ui icon message #{color_class}") do
-          concat(icon_tag(icon_class))
-          inner = content_tag('div', class: 'content') do
-            concat(content_tag('div', title, class: 'header'))
-            concat(capture(&block))
-          end
-          concat(inner)
+      def aaf_home_link
+        content_tag('a', href: 'https://aaf.edu.au') do
+          concat(icon_tag('aaf'))
+          concat(' AAF Home')
+        end
+      end
+
+      def aaf_support_link
+        content_tag('a', href: 'https://support.aaf.edu.au') do
+          concat(icon_tag('user'))
+          concat(' Support')
+        end
+      end
+
+      def aaf_auth_link(auth)
+        return if auth.nil?
+
+        text = ' Log In'
+        text = ' Log Out' if auth == :logout
+
+        icon = 'log-in'
+        icon = 'log-out' if auth == :logout
+
+        content_tag('a', href: "/auth/#{auth}") do
+          concat(icon_tag(icon))
+          concat(text)
+        end
+      end
+
+      def aaf_environment_string(environment)
+        return unless environment&.present?
+        content_tag('span', environment, class: 'environment')
+      end
+
+      def alert_block(title, color_class, &block)
+        opts = { class: "alert alert-#{color_class}", role: 'alert' }
+        content_tag('div', opts) do
+          concat(content_tag('h4', title))
+          concat(capture(&block))
         end
       end
 

data/lib/lipstick/helpers/nav_helper.rb

@@ -1,48 +1,43 @@
+# frozen_string_literal: true
 module Lipstick
   module Helpers
     module NavHelper
-      include ActionView::Helpers::TagHelper
-      include ActionView::Helpers::TextHelper
+      def nav_bar
+        content_tag('nav', class: 'navbar shrink') { yield }
+      end
 
-      def nav_bar(&block)
-        content_tag('nav') do
-          css_class = 'ui borderless inverted menu collapsing nav parent'
-          content_tag('div', class: css_class) do
-            concat(nav_collapse_button)
-            concat(capture(&block))
-          end
+      def nav_first_item(text, url)
+        content_tag('div', class: 'nav navbar-header') do
+          concat(nav_collapse_button)
+          concat(content_tag('a', text, href: url, class: 'navbar-brand'))
         end
       end
 
-      def nav_collapsing_items(&block)
-        content_tag('span', class: 'collapsing nav content', &block)
+      def nav_collapsing_items
+        attrs = { class: 'collapse navbar-collapse', id: 'aaf-nav-collapse' }
+        content_tag('div', attrs) do
+          content_tag('ul', class: 'nav navbar-nav') { yield }
+        end
       end
 
       def nav_item(text, url, html_opts = {})
-        html_opts[:class] = "#{html_opts[:class]} item".strip
-        content_tag('a', text, html_opts.merge(href: url))
-      end
-
-      def nav_items_right(&block)
-        content_tag('div', class: 'right menu', &block)
-      end
-
-      def nav_dropdown(title, &block)
-        content_tag('div', class: 'ui simple dropdown item') do
-          concat(content_tag('i', '', class: 'dropdown icon'))
-          concat(title)
-          concat(content_tag('div', class: 'menu', &block))
+        content_tag('li') do
+          content_tag('a', text, html_opts.merge(href: url))
         end
       end
 
       private
 
       def nav_collapse_button
-        content_tag('div', class: 'collapsing nav button') do
-          content_tag('a', href: '#',
-                           class: 'ui icon mini black open button') do
-            content_tag('i', '', class: 'list layout icon')
-          end
+        attrs = {
+          type: 'button', class: 'navbar-toggle collapsed',
+          'data-toggle': 'collapse', 'data-target': '#aaf-nav-collapse',
+          'aria-expanded': 'false'
+        }
+
+        content_tag('button', attrs) do
+          concat(content_tag('span', 'Toggle navigation', class: 'sr-only'))
+          3.times { concat(content_tag('span', '', class: 'icon-bar')) }
         end
       end
     end

data/lib/lipstick/helpers/pagination_link_renderer.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+require 'will_paginate'
+
+module Lipstick
+  module Helpers
+    class PaginationLinkRenderer
+      attr_reader :items, :current, :total, :template
+      private :current, :total, :template
+
+      def prepare(collection, _options, template)
+        @current = collection.current_page
+        @total = collection.total_pages
+
+        @items = [*prefix, *middle, *suffix]
+        @template = template
+      end
+
+      def to_html
+        template.content_tag('nav', class: 'pagination-wrapper') do
+          template.content_tag('ul', class: 'pagination') do
+            items.each do |item|
+              template.concat(render_item(item))
+            end
+          end
+        end
+      end
+
+      private
+
+      def prefix
+        return [:prev] if !show_first? || short_list?
+        return [:prev, 1, :gap] if prefix_gap?
+        [:prev, 1]
+      end
+
+      def middle
+        return page_range(1, total) if short_list?
+        page_range(*page_window)
+      end
+
+      # Decides which pages to show in the links surrounding the "current" page.
+      def page_window
+        # If we're close to the start/end we can show a few extra page links.
+        return [1, 8] if current < 5
+        return [total - 7, total] if current > total - 4
+
+        # Otherwise show 3 pages either side of the current page
+        [current - 3, current + 3]
+      end
+
+      def suffix
+        return [:next] if !show_last? || short_list?
+        return [:gap, total, :next] if suffix_gap?
+        [total, :next]
+      end
+
+      def page_range(start, finish)
+        [start, 1].max.upto([finish, total].min)
+      end
+
+      def short_list?
+        total <= 10
+      end
+
+      def show_first?
+        !middle.include?(1)
+      end
+
+      def show_last?
+        !middle.include?(total)
+      end
+
+      def prefix_gap?
+        !middle.include?(2)
+      end
+
+      def suffix_gap?
+        !middle.include?(total - 1)
+      end
+
+      def render_item(item)
+        case item
+        when :prev
+          prev_item
+        when :next
+          next_item
+        when :gap
+          gap_item
+        else
+          link_to_page(item, page: item)
+        end
+      end
+
+      def prev_item
+        icon = template.content_tag('span', "\u25C0", 'aria-hidden': 'true')
+
+        return disabled_item(icon) if current < 2
+        link_to_page(icon, page: current - 1, 'aria-label': 'Previous')
+      end
+
+      def next_item
+        icon = template.content_tag('span', "\u25B6", 'aria-hidden': 'true')
+
+        return disabled_item(icon) if current >= total
+        link_to_page(icon, page: current + 1, 'aria-label': 'Next')
+      end
+
+      def gap_item
+        template.content_tag('li') do
+          template.content_tag('span', "\u2026", 'aria-hidden': 'true')
+        end
+      end
+
+      def link_to_page(content, page:, **opts)
+        li_opts = {}
+        li_opts[:class] = 'active' if page == current
+
+        url_opts = template.params.merge(page: page)
+        opts = opts.merge(href: template.url_for(url_opts))
+
+        template.content_tag('li', li_opts) do
+          template.content_tag('a', content, opts)
+        end
+      end
+
+      def disabled_item(content)
+        template.content_tag('li', content, class: 'disabled')
+      end
+    end
+  end
+end