foundation_rails_helper 2.0.0 → 3.0.0.beta3

data/lib/foundation_rails_helper/form_builder.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 require 'action_view/helpers'
 
 module FoundationRailsHelper
   class FormBuilder < ActionView::Helpers::FormBuilder
     include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::OutputSafetyHelper
     %w(file_field email_field text_field text_area telephone_field phone_field
        url_field number_field date_field datetime_field datetime_local_field
        month_field week_field time_field range_field search_field color_field)
@@ -17,21 +19,23 @@ module FoundationRailsHelper
     end
 
     def label(attribute, text = nil, options = {})
-      if has_error?(attribute)
+      if error?(attribute)
         options[:class] ||= ''
-        options[:class] += ' error'
+        options[:class] += ' is-invalid-label'
       end
 
       super(attribute, (text || '').html_safe, options)
     end
 
+    # rubocop:disable LineLength
     def check_box(attribute, options = {}, checked_value = '1', unchecked_value = '0')
       custom_label(attribute, options[:label], options[:label_options]) do
         options.delete(:label)
         options.delete(:label_options)
         super(attribute, options, checked_value, unchecked_value)
-      end + error_and_hint(attribute, options)
+      end + error_and_help_text(attribute, options)
     end
+    # rubocop:enable LineLength
 
     def radio_button(attribute, tag_value, options = {})
       options[:label_options] ||= {}
@@ -62,12 +66,14 @@ module FoundationRailsHelper
       end
     end
 
+    # rubocop:disable LineLength
     def time_zone_select(attribute, priorities = nil, options = {}, html_options = {})
       field attribute, options, html_options do |html_opts|
         super(attribute, priorities, options,
               html_opts.merge(autocomplete: :off))
       end
     end
+    # rubocop:enable LineLength
 
     def select(attribute, choices, options = {}, html_options = {})
       field attribute, options, html_options do |html_opts|
@@ -76,6 +82,7 @@ module FoundationRailsHelper
       end
     end
 
+    # rubocop:disable LineLength, ParameterLists
     def collection_select(attribute, collection, value_method, text_method, options = {}, html_options = {})
       field attribute, options, html_options do |html_opts|
         html_options[:autocomplete] ||= :off
@@ -91,6 +98,7 @@ module FoundationRailsHelper
               option_key_method, option_value_method, options, html_opts)
       end
     end
+    # rubocop:enable LineLength, ParameterLists
 
     def autocomplete(attribute, url, options = {})
       field attribute, options do |opts|
@@ -105,71 +113,43 @@ module FoundationRailsHelper
       super(value, options)
     end
 
-    private
-
-    def has_error?(attribute)
-      object.respond_to?(:errors) && !object.errors[attribute].blank?
-    end
-
     def error_for(attribute, options = {})
-      class_name = 'error'
-      class_name += " #{options[:class]}" if options[:class]
+      return unless error?(attribute)
 
-      return unless has_error?(attribute)
+      class_name = 'form-error is-visible'
+      class_name += " #{options[:class]}" if options[:class]
 
       error_messages = object.errors[attribute].join(', ')
       error_messages = error_messages.html_safe if options[:html_safe_errors]
-      content_tag(:small, error_messages, class: class_name)
+      content_tag(:small, error_messages,
+                  class: class_name.sub('is-invalid-input', ''))
     end
 
-    def custom_label(attribute, text, options)
-      return block_given? ? yield.html_safe : ''.html_safe if text == false
-      if text.nil? || text == true
-        text =
-          if object.class.respond_to?(:human_attribute_name)
-            object.class.human_attribute_name(attribute)
-          else
-            attribute.to_s.humanize
-          end
-      end
-      text = yield.html_safe + " #{text}" if block_given?
-      options ||= {}
-      label(attribute, text, options)
-    end
+    private
 
-    def column_classes(options)
-      classes = SizeClassCalcluator.new(options).classes
-      classes + ' columns'
+    def error?(attribute)
+      object.respond_to?(:errors) && !object.errors[attribute].blank?
     end
 
-    class SizeClassCalcluator
-      def initialize(size_options)
-        @small = size_options[:small]
-        @medium = size_options[:medium]
-        @large = size_options[:large]
+    def default_label_text(object, attribute)
+      if object.class.respond_to?(:human_attribute_name)
+        return object.class.human_attribute_name(attribute)
       end
 
-      def classes
-        [small_class, medium_class, large_class].compact.join(' ')
-      end
-
-      private
-
-      def small_class
-        "small-#{@small}" if valid_size(@small)
-      end
+      attribute.to_s.humanize
+    end
 
-      def medium_class
-        "medium-#{@medium}" if valid_size(@medium)
-      end
+    def custom_label(attribute, text, options)
+      return block_given? ? yield.html_safe : ''.html_safe if text == false
 
-      def large_class
-        "large-#{@large}" if valid_size(@large)
-      end
+      text = default_label_text(object, attribute) if text.nil? || text == true
+      text = safe_join([yield, text.html_safe]) if block_given?
+      label(attribute, text, options || {})
+    end
 
-      def valid_size(value)
-        value.present? && value.to_i < 12
-      end
+    def column_classes(options)
+      classes = SizeClassCalculator.new(options).classes
+      classes + ' columns'
     end
 
     def tag_from_options(name, options)
@@ -181,7 +161,7 @@ module FoundationRailsHelper
     end
 
     def decrement_input_size(input, column, options)
-      return unless options.key?(column)
+      return unless options.present? && options.key?(column)
 
       input.send("#{column}=",
                  (input.send(column) - options.fetch(column).to_i))
@@ -191,15 +171,9 @@ module FoundationRailsHelper
     def calculate_input_size(prefix_options, postfix_options)
       input_size =
         OpenStruct.new(changed?: false, small: 12, medium: 12, large: 12)
-      if prefix_options.present?
-        %w(small medium large).each do |size|
-          decrement_input_size(input_size, size.to_sym, prefix_options)
-        end
-      end
-      if postfix_options.present?
-        %w(small medium large).each do |size|
-          decrement_input_size(input_size, size.to_sym, postfix_options)
-        end
+      %w(small medium large).each do |size|
+        decrement_input_size(input_size, size.to_sym, prefix_options)
+        decrement_input_size(input_size, size.to_sym, postfix_options)
       end
 
       input_size
@@ -213,45 +187,49 @@ module FoundationRailsHelper
       klass = column_classes(input_size.marshal_dump).to_s
       input = content_tag(:div, block, class: klass)
 
-      html =
-        if input_size.changed?
-          content_tag(:div, prefix + input + postfix, class: 'row collapse')
-        else
-          block
-        end
-
-      html.html_safe
+      return block unless input_size.changed?
+      content_tag(:div, prefix + input + postfix, class: 'row collapse')
     end
 
-    def error_and_hint(attribute, options = {})
+    def error_and_help_text(attribute, options = {})
       html = ''
-      html += content_tag(:span, options[:hint], class: :hint) if options[:hint]
+      if options[:help_text]
+        html += content_tag(:p, options[:help_text], class: 'help-text')
+      end
       html += error_for(attribute, options) || ''
       html.html_safe
     end
 
+    def field_label(attribute, options)
+      return ''.html_safe unless auto_labels || options[:label]
+      custom_label(attribute, options[:label], options[:label_options])
+    end
+
     def field(attribute, options, html_options = nil)
-      auto_labels = true unless @options[:auto_labels] == false
-      html = if auto_labels || options[:label]
-               custom_label(attribute, options[:label], options[:label_options])
-             else
-               ''.html_safe
-             end
+      html = field_label(attribute, options)
       class_options = html_options || options
 
-      if has_error?(attribute)
+      if error?(attribute)
         class_options[:class] = class_options[:class].to_s
-        class_options[:class] += ' error'
+        class_options[:class] += ' is-invalid-input'
       end
 
       options.delete(:label)
       options.delete(:label_options)
-      hint = options.delete(:hint)
+      help_text = options.delete(:help_text)
       prefix = options.delete(:prefix)
       postfix = options.delete(:postfix)
 
       html += wrap_prefix_and_postfix(yield(class_options), prefix, postfix)
-      html + error_and_hint(attribute, options.merge(hint: hint))
+      html + error_and_help_text(attribute, options.merge(help_text: help_text))
+    end
+
+    def auto_labels
+      if @options[:auto_labels].nil?
+        FoundationRailsHelper.configuration.auto_labels
+      else
+        @options[:auto_labels]
+      end
     end
   end
 end

data/lib/foundation_rails_helper/size_class_calculator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module FoundationRailsHelper
+  class SizeClassCalculator
+    def initialize(size_options)
+      @small = size_options[:small]
+      @medium = size_options[:medium]
+      @large = size_options[:large]
+    end
+
+    def classes
+      [small_class, medium_class, large_class].compact.join(' ')
+    end
+
+    private
+
+    def small_class
+      "small-#{@small}" if valid_size(@small)
+    end
+
+    def medium_class
+      "medium-#{@medium}" if valid_size(@medium)
+    end
+
+    def large_class
+      "large-#{@large}" if valid_size(@large)
+    end
+
+    def valid_size(value)
+      value.present? && value.to_i < 12
+    end
+  end
+end

data/lib/foundation_rails_helper/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module FoundationRailsHelper
-  VERSION = '2.0.0'.freeze
+  VERSION = '3.0.0.beta3'
 end

data/lib/railtie.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Railtie
   class Railtie < Rails::Railtie
     # initializer 'setup foundation form builder' do

data/spec/.rubocop.yml

@@ -5,3 +5,6 @@ StringLiterals:
   EnforcedStyle: double_quotes
   Exclude:
     - './spec_helper.rb'
+
+Metrics/BlockLength:
+  Enabled: false

data/spec/foundation_rails_helper/configuration_spec.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
 require "spec_helper"
 
 describe FoundationRailsHelper do
   describe FoundationRailsHelper::Configuration do
     describe "#button_class" do
-      it "default value is 'small radius success button'" do
+      it "default value is 'success button'" do
         config = FoundationRailsHelper::Configuration.new
-        expect(config.button_class).to eq("small radius success button")
+        expect(config.button_class).to eq("success button")
       end
     end
 
@@ -32,6 +33,21 @@ describe FoundationRailsHelper do
       end
     end
 
+    describe "#auto_labels" do
+      it "default value is 'true'" do
+        config = FoundationRailsHelper::Configuration.new
+        expect(config.auto_labels).to be(true)
+      end
+    end
+
+    describe "#auto_labels=" do
+      it "can set the value" do
+        config = FoundationRailsHelper::Configuration.new
+        config.auto_labels = false
+        expect(config.auto_labels).to be(false)
+      end
+    end
+
     describe ".reset" do
       it "resets the configured button class" do
         FoundationRailsHelper.configure do |config|
@@ -41,7 +57,7 @@ describe FoundationRailsHelper do
         FoundationRailsHelper.reset
 
         config = FoundationRailsHelper.configuration
-        expect(config.button_class).to eq("small radius success button")
+        expect(config.button_class).to eq("success button")
       end
 
       it "resets the configured ignored flash keys" do
@@ -54,6 +70,17 @@ describe FoundationRailsHelper do
         config = FoundationRailsHelper.configuration
         expect(config.ignored_flash_keys).to eq([])
       end
+
+      it "resets the configured auto labels" do
+        FoundationRailsHelper.configure do |config|
+          config.auto_labels = false
+        end
+
+        FoundationRailsHelper.reset
+
+        config = FoundationRailsHelper.configuration
+        expect(config.auto_labels).to be(true)
+      end
     end
   end
 end

data/spec/foundation_rails_helper/flash_helper_spec.rb

@@ -1,60 +1,64 @@
-# encoding: utf-8
-
+# frozen_string_literal: true
 require "spec_helper"
 
 describe FoundationRailsHelper::FlashHelper do
   include ActionView::Context if defined?(ActionView::Context)
-  include ActionView::Helpers::UrlHelper
-  include ActionView::Helpers::TagHelper
-  include ActionView::Helpers::TextHelper
+  include ActionView::Helpers::FormTagHelper
   include FoundationRailsHelper::FlashHelper
 
-  FoundationRailsHelper::FlashHelper::DEFAULT_KEY_MATCHING.each do |message_type, foundation_type|
-    it "displays flash message with #{foundation_type} class for #{message_type} message" do
-      allow(self).to receive(:flash).and_return(message_type.to_s => "Flash message")
+  KEY_MATCHING = FoundationRailsHelper::FlashHelper::DEFAULT_KEY_MATCHING.freeze
+
+  KEY_MATCHING.each do |type, klass|
+    it "displays flash message with #{klass} class for #{type} message" do
+      allow(self).to receive(:flash).and_return(type.to_s => "Flash message")
       node = Capybara.string display_flash_messages
       expect(node)
-        .to  have_css("div.alert-box.#{foundation_type}", text: "Flash message")
-        .and have_css("div.alert-box a.close", text: "×")
+        .to  have_css("div.flash.callout.#{klass}", text: "Flash message")
+        .and have_css("[data-close]", text: "×")
     end
   end
 
   it "handles symbol keys" do
     allow(self).to receive(:flash).and_return(success: "Flash message")
     node = Capybara.string display_flash_messages
-    expect(node).to have_css("div.alert-box.success", text: "Flash message")
+    expect(node).to have_css("div.callout.success", text: "Flash message")
   end
 
   it "handles string keys" do
     allow(self).to receive(:flash).and_return("success" => "Flash message")
     node = Capybara.string display_flash_messages
-    expect(node).to have_css("div.alert-box.success", text: "Flash message")
+    expect(node).to have_css("div.callout.success", text: "Flash message")
   end
 
   it "displays multiple flash messages" do
-    allow(self).to receive(:flash).and_return("success" => "Yay it worked", "error" => "But this other thing failed")
+    allow(self).to receive(:flash)
+      .and_return("success" => "Yay it worked",
+                  "error" => "But this other thing failed")
     node = Capybara.string display_flash_messages
     expect(node)
-      .to  have_css("div.alert-box.success", text: "Yay it worked")
-      .and have_css("div.alert-box.alert",   text: "But this other thing failed")
+      .to  have_css("div.callout.success", text: "Yay it worked")
+      .and have_css("div.callout.alert",   text: "But this other thing failed")
   end
 
   it "displays flash message with overridden key matching" do
     allow(self).to receive(:flash).and_return("notice" => "Flash message")
-    node = Capybara.string display_flash_messages(notice: :alert)
-    expect(node).to have_css("div.alert-box.alert", text: "Flash message")
+    node =
+      Capybara.string display_flash_messages(key_matching: { notice: :alert })
+    expect(node).to have_css("div.callout.alert", text: "Flash message")
   end
 
   it "displays flash message with custom key matching" do
     allow(self).to receive(:flash).and_return("custom_type" => "Flash message")
-    node = Capybara.string display_flash_messages(custom_type: :custom_class)
-    expect(node).to have_css("div.alert-box.custom_class", text: "Flash message")
+    node = Capybara.string(
+      display_flash_messages(key_matching: { custom_type: :custom_class })
+    )
+    expect(node).to have_css("div.callout.custom_class", text: "Flash message")
   end
 
   it "displays flash message with standard class if key doesn't match" do
     allow(self).to receive(:flash).and_return("custom_type" => "Flash message")
     node = Capybara.string display_flash_messages
-    expect(node).to have_css("div.alert-box.standard", text: "Flash message")
+    expect(node).to have_css("div.callout.primary", text: "Flash message")
   end
 
   context "when the flash hash contains devise internal data" do
@@ -73,13 +77,23 @@ describe FoundationRailsHelper::FlashHelper do
       allow(self).to receive(:flash).and_return("timedout" => true)
       expect(display_flash_messages).to be_nil
 
-      # Ideally we'd create a node using Capybara.string, as in the other examples
-      # and set the following expectation:
-      #   expect(node).to_not have_css("div.alert-box")
+      # Ideally we'd create a node using Capybara.string, as in the other
+      # examples and set the following expectation:
+      #   expect(node).to_not have_css("div.callout")
       # but Capybara.string doesn't behave nicely with nil input:
       # the input gets assigned to the @native instance variable,
       # which is used by the css matcher, so we get the following error:
       #   undefined method `css' for nil:NilClass
     end
   end
+
+  context "with (closable: false) option" do
+    it "doesn't display the close button" do
+      allow(self).to receive(:flash).and_return(success: "Flash message")
+      node = Capybara.string display_flash_messages(closable: false)
+      expect(node)
+        .to  have_css("div.flash.callout.success", text: "Flash message")
+        .and have_no_css("[data-close]", text: "×")
+    end
+  end
 end