aaf-lipstick 1.1.0

data/lib/aaf-lipstick.rb

@@ -0,0 +1 @@
+require 'lipstick'

data/lib/lipstick.rb

@@ -0,0 +1,12 @@
+module Lipstick
+  def self.asset_path
+    File.expand_path(File.join('..', 'app', 'assets'), File.dirname(__FILE__))
+  end
+end
+
+require 'lipstick/helpers'
+require 'lipstick/email_message'
+require 'lipstick/images'
+require 'lipstick/auto_validation'
+require 'lipstick/engine' if defined?(Rails::Engine)
+require 'lipstick/action_view_tilt_template' if defined?(Tilt)

data/lib/lipstick/action_view_tilt_template.rb

@@ -0,0 +1,17 @@
+require 'action_view'
+
+module Lipstick
+  class ActionViewTiltTemplate < Tilt::ERBTemplate
+    def prepare
+      @engine = ActionView::Template::Handlers::Erubis.new(data, options)
+    end
+
+    def precompiled_preamble(_locals)
+      ''
+    end
+
+    def precompiled_postamble(_locals)
+      ''
+    end
+  end
+end

data/lib/lipstick/auto_validation.rb

@@ -0,0 +1,73 @@
+require 'active_model'
+
+module Lipstick
+  module AutoValidation
+    module ClassMethods
+      def self.extended(base)
+        return if base.respond_to?(:validators)
+
+        fail('Lipstick::AutoValidation requires a class which responds' \
+             ' to the `validators` method. For example, as provided by' \
+             ' ActiveModel::Validations')
+      end
+
+      def lipstick_auto_validators
+        validators.each_with_object({}) do |validator, map|
+          validator.attributes.each do |attr|
+            out = semantic_ui_validator(attr, validator)
+            next if out.nil?
+
+            map[attr.to_sym] ||= {}
+            map[attr.to_sym].merge!(out)
+          end
+        end
+      end
+
+      private
+
+      v = ActiveModel::Validations
+      VALIDATOR_TRANSLATORS = {
+        v::PresenceValidator => :semantic_presence_validator,
+        v::LengthValidator => :semantic_length_validator,
+        v::NumericalityValidator => :semantic_numericality_validator
+      }
+      private_constant :VALIDATOR_TRANSLATORS
+
+      def semantic_ui_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))
+        end
+        nil
+      end
+
+      def semantic_presence_validator(_attr, _validator, humanized)
+        { empty: "Please enter a value for #{humanized}" }
+      end
+
+      def semantic_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)"
+
+        {}.tap do |out|
+          out["length[#{min}]"] = min_message if min
+          out["maxLength[#{max}]"] = max_message if max
+        end
+      end
+
+      def semantic_numericality_validator(_attr, _validator, humanized)
+        { integer: "Please enter a numeric value for #{humanized}" }
+      end
+    end
+
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+  end
+end

data/lib/lipstick/email_message.rb

@@ -0,0 +1,29 @@
+require 'kramdown'
+require 'erubis'
+
+module Lipstick
+  class EmailMessage
+    attr_reader :title, :image_url, :content, :template
+
+    def initialize(title:, content:, image_url:, template: default_template)
+      @title = title
+      @content = Kramdown::Document.new(content).to_html
+      @image_url = image_url
+      @template = template
+    end
+
+    def render
+      Erubis::Eruby.new(template).result(binding)
+    end
+
+    private
+
+    TEMPLATE_PATH = '../../app/views/layouts/email_branding.html.erb'
+    private_constant :TEMPLATE_PATH
+
+    def default_template
+      file = File.expand_path(TEMPLATE_PATH, File.dirname(__FILE__))
+      File.read(file)
+    end
+  end
+end

data/lib/lipstick/engine.rb

@@ -0,0 +1,11 @@
+module Lipstick
+  class Engine < ::Rails::Engine
+    isolate_namespace Lipstick
+
+    initializer :assets do |app|
+      app.config.assets.tap do |assets|
+        assets.paths << root.join('app', 'assets', 'images')
+      end
+    end
+  end
+end

data/lib/lipstick/helpers.rb

@@ -0,0 +1,9 @@
+module Lipstick
+  module Helpers
+  end
+end
+
+require 'lipstick/helpers/layout_helper'
+require 'lipstick/helpers/nav_helper'
+require 'lipstick/helpers/semantic_form_builder'
+require 'lipstick/helpers/form_helper'

data/lib/lipstick/helpers/form_helper.rb

@@ -0,0 +1,197 @@
+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
+        end
+
+        html_opts[:class] = "#{html_opts[:class]} field".strip
+        content_tag('div', html_opts, &block)
+      end
+
+      alias_method :orig_form_tag, :form_tag
+
+      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)
+      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)
+        end
+      end
+
+      def hidden_fields(&block)
+        content_tag('div', style: 'display: none;', &block)
+      end
+
+      def text_field_tag(*args)
+        content_tag('div', class: 'ui input') { super }
+      end
+
+      def field_help_text(text)
+        icon_tag('field-help-text blue help', 'data-content' => text)
+      end
+
+      def button_tag(content_or_options = nil, options = nil, &block)
+        add_class = ->(m) { m.dup.merge(class: "#{m[:class]} ui button".strip) }
+
+        if content_or_options.is_a?(Hash)
+          super(add_class.call(content_or_options), &block)
+        else
+          super(content_or_options, add_class.call(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
+
+      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
+        end
+      end
+
+      def form_for(obj, opts = {}, &block)
+        opts[:builder] = SemanticFormBuilder
+        opts[:html] ||= {}
+        opts[:html][:class] = "#{opts[:html][:class]} ui form".strip
+        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
+        end
+      end
+
+      private
+
+      def validation_body(selector, sym, &block)
+        'var validations = {};' +
+          validation_name_mapping_function(sym) +
+          capture(&block) +
+          validation_install(selector)
+      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 validation_install(selector)
+        format('$(%s).form(validations, { keyboardShortcuts: false });',
+               selector.to_json)
+      end
+
+      def jquery_callback(body)
+        format('jQuery(function($){%s});', body)
+      end
+
+      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;'
+      end
+
+      def with_flag_enabled(flag)
+        old = Thread.current[flag]
+        begin
+          Thread.current[flag] = true
+          yield
+        ensure
+          Thread.current[flag] = old
+        end
+      end
+
+      def flag_enabled?(flag)
+        Thread.current[flag]
+      end
+    end
+  end
+end

data/lib/lipstick/helpers/layout_helper.rb

@@ -0,0 +1,143 @@
+require 'action_view'
+
+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)
+        content_tag('div', class: 'aaf-header') do
+          concat(aaf_banner(title, environment))
+          concat(capture(&bl))
+        end
+      end
+
+      def aaf_footer(&bl)
+        content_tag('footer') do
+          concat(content_tag('div', '', class: 'ui divider'))
+          concat(capture(&bl))
+        end
+      end
+
+      def logged_in_user(user)
+        return if user.nil?
+        content_tag('p') do
+          concat('Logged in as: ')
+          concat(content_tag('strong', user.name))
+          concat(" (#{user.targeted_id})")
+        end
+      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'))
+          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)
+      end
+
+      # button_link_to(url_opts) { 'Link Text' }
+      # button_link_to(url_opts, html_opts) { 'Link Text' }
+      # button_link_to('Link Text', url_opts)
+      # button_link_to('Link Text', url_opts, html_opts)
+      def button_link_to(*args, &block)
+        args.unshift(capture(&block)) if block_given?
+        text, url_opts, html_opts = args
+        html_opts ||= {}
+        html_opts[:class] = "#{html_opts[:class]} ui button".strip
+        link_to(text, url_opts, html_opts)
+      end
+
+      def info_message(title, &block)
+        message_block(title, 'info', 'info', &block)
+      end
+
+      def error_message(title, &block)
+        message_block(title, 'error', 'warning', &block)
+      end
+
+      def success_message(title, &block)
+        message_block(title, 'success', 'smile', &block)
+      end
+
+      def warning_message(title, &block)
+        message_block(title, 'warning', 'warning', &block)
+      end
+
+      def breadcrumbs(*links)
+        content_tag('div', class: 'ui 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'))
+          end
+
+          concat(content_tag('div', breadcrumb_link(last),
+                             class: 'active section'))
+        end
+      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'))
+          end
+          concat(header)
+        end
+      end
+
+      def aaf_environment_string(environment)
+        return if environment.nil?
+        content_tag('div', environment, class: 'environment')
+      end
+
+      def image_path(*)
+        unless defined?(super)
+          fail('No image_path method was found. This is typically provided by' \
+               ' Rails or Sprockets::Helpers')
+        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)
+        end
+      end
+
+      def breadcrumb_link(item)
+        return item if item.is_a?(String)
+        item.reduce(nil) { |_, (k, v)| content_tag('a', k, href: v) }
+      end
+    end
+  end
+end