effective_bootstrap 0.7.3

data/app/models/effective/form_inputs/check_box.rb

@@ -0,0 +1,70 @@
+module Effective
+  module FormInputs
+    class CheckBox < Effective::FormInput
+
+      def to_html(&block)
+        case layout
+        when :horizontal
+          build_wrapper do
+            content_tag(:div, '', class: 'col-sm-2') + content_tag(:div, build_content(&block), class: 'col-sm-10')
+          end
+        else
+          build_content(&block)
+        end
+      end
+
+      def build_content(&block)
+        build_check_box_wrap { build_input(&block) + build_label + build_feedback + build_hint }
+      end
+
+      def build_check_box_wrap(&block)
+        if custom?
+          content_tag(:div, yield, options[:wrapper])
+        else
+          content_tag(:div, yield, options[:wrapper])
+        end
+      end
+
+      def wrapper_options
+        if custom? && inline?
+          { class: 'form-group custom-control custom-checkbox custom-control-inline' }
+        elsif custom?
+          { class: 'form-group custom-control custom-checkbox' }
+        elsif inline?
+          { class: 'form-check form-check-inline' }
+        else
+          { class: 'form-check' }
+        end
+      end
+
+      def label_options
+        if custom?
+          { class: 'custom-control-label' }
+        else
+          { class: 'form-check-label' }
+        end
+      end
+
+      def input_html_options
+        if custom?
+          { class: 'custom-control-input', id: unique_id }
+        else
+          { class: 'form-check-input', id: unique_id }
+        end
+      end
+
+      private
+
+      def inline? # default false
+        return @inline unless @inline.nil?
+        @inline = ((options[:input] || {}).delete(:inline) == true)
+      end
+
+      def custom? # default true
+        return @custom unless @custom.nil?
+        @custom = (options.delete(:custom) != false)
+      end
+
+    end
+  end
+end

data/app/models/effective/form_inputs/checks.rb

@@ -0,0 +1,99 @@
+module Effective
+
+  module FormInputs
+    class Checks < CollectionInput
+
+      def build_input(&block)
+        html = @builder.collection_check_boxes(name, options_collection, value_method, label_method, collection_options, item_input_options) { |builder| build_item(builder) }
+
+        if disabled? # collection_check_boxes doesn't correctly disable the input type hidden, but does on the build_items
+          html = html.sub('<input type="hidden"', '<input type="hidden" disabled="disabled"').html_safe
+        end
+
+        html
+      end
+
+      def build_wrapper(&block)
+        if layout == :horizontal
+          content_tag(:fieldset, content_tag(:div, yield, class: 'row'), options[:wrapper])
+        else
+          content_tag(:fieldset, yield, options[:wrapper])
+        end
+      end
+
+      def wrapper_options
+        { class: [
+            'form-group effective-checks',
+            ('no-feedback' unless feedback_options),
+            tag_id,
+            ('is-invalid' if feedback_options && has_error?(name)),
+            ('is-valid' if feedback_options && has_error? && !has_error?(name))
+          ].compact.join(' ')
+        }
+      end
+
+      def feedback_options
+        return false if layout == :inline
+
+        {
+          valid: { class: 'valid-feedback' }.compact,
+          invalid: { class: 'invalid-feedback' }.compact
+        }
+      end
+
+      def input_html_options
+        if custom?
+          { class: 'custom-control-input' }
+        else
+          { class: 'form-check-input' }
+        end
+      end
+
+      def build_label
+        return BLANK if options[:label] == false
+        return BLANK if name.kind_of?(NilClass)
+
+        text = (options[:label].delete(:text) || (object.class.human_attribute_name(name) if object) || BLANK).html_safe
+
+        content_tag(:label, options[:label]) do
+          text + content_tag(:div, class: 'effective-checks-actions text-muted') do
+            unless disabled? || !actions?
+              link_to('Select All', '#', 'data-effective-checks-all': true) + ' - ' + link_to('Select None', '#', 'data-effective-checks-none': true)
+            end
+          end
+        end
+      end
+
+      def build_item(builder)
+        item_id = unique_id(builder.object)
+        build_item_wrap { builder.check_box(id: item_id) + builder.label(item_label_options.merge(for: item_id)) }
+      end
+
+      def build_item_wrap(&block)
+        if custom?
+          content_tag(:div, yield, class: 'custom-control custom-checkbox ' + (inline? ? 'custom-control-inline' : 'form-group'))
+        else
+          content_tag(:div, yield, class: 'form-check' + (inline? ? ' form-check-inline' : ''))
+        end
+      end
+
+      def item_input_options
+        options[:input].except(:inline, :custom, :required)
+      end
+
+      def item_label_options
+        if custom?
+          { class: 'custom-control-label' }
+        else
+          { class: 'form-check-label' }
+        end
+      end
+
+      def actions? # default true
+        return @actions unless @actions.nil?
+        @actions = (options.delete(:actions) != false)
+      end
+
+    end
+  end
+end

data/app/models/effective/form_inputs/ck_editor.rb

@@ -0,0 +1,48 @@
+module Effective
+  module FormInputs
+    class CkEditor < Effective::FormInput
+
+      def build_input(&block)
+        content = value.presence || (capture(&block) if block_given?)
+        @builder.super_text_area(name, (options[:input] || {}).merge(autocomplete: 'off'))
+      end
+
+      def input_html_options
+        { class: 'effective_ck_editor form-control', id: unique_id }
+      end
+
+      def input_js_options
+        {
+          effective_ckeditor_js_path: asset_path('effective_ckeditor.js'),
+          effective_ckeditor_css_path: asset_path('effective_ckeditor.css'),
+          contentsCss: contentsCss,
+          toolbar: toolbar,
+          height: height,
+          width: width
+        }.compact
+      end
+
+      def contentsCss
+        @contents_css ||= case (obj = options.delete(:contentsCss))
+        when :bootstrap
+          'https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css'
+        when false then nil
+        else obj || asset_path('application.css')
+        end
+      end
+
+      def toolbar
+        @toolbar ||= (options.delete(:toolbar) || :full)
+      end
+
+      def height
+        @height ||= options.delete(:height)
+      end
+
+      def width
+        @width ||= options.delete(:width)
+      end
+
+    end
+  end
+end

data/app/models/effective/form_inputs/clear.rb

@@ -0,0 +1,22 @@
+module Effective
+  module FormInputs
+    class Clear < Effective::FormInput
+
+      def to_html(&block)
+        content_tag(:button, options[:input]) do
+          icon_name.present? ? (icon(icon_name) + name) : name
+        end
+      end
+
+      def input_html_options
+        { class: 'btn btn-primary', type: 'clear' }
+      end
+
+      def icon_name
+        return @icon unless @icon.nil?
+        @icon = options[:input].delete(:icon) || ''.html_safe
+      end
+
+    end
+  end
+end

data/app/models/effective/form_inputs/collection_input.rb

@@ -0,0 +1,168 @@
+module Effective
+  module FormInputs
+    class CollectionInput < Effective::FormInput
+      def initialize(name, options, builder:, html_options: nil)
+        super
+        assign_options_collection!
+        assign_options_collection_methods!
+      end
+
+      def polymorphic?
+        return @polymorphic unless @polymorphic.nil?
+        @polymorphic = (options.delete(:polymorphic) || false)
+      end
+
+      def grouped?
+        return @grouped unless @grouped.nil?
+        @grouped = (options.delete(:grouped) || false)
+      end
+
+      def custom? # default true
+        return @custom unless @custom.nil?
+        @custom = (options.delete(:custom) != false)
+      end
+
+      def inline? # default false
+        return @inline unless @inline.nil?
+        @inline = (options[:input].delete(:inline) == true)
+      end
+
+      def collection_options
+        return @collection_options unless @collection_options.nil?
+
+        checked = options[:input].delete(:checked)
+        selected = options[:input].delete(:selected)
+        include_blank = options[:input].delete(:include_blank)
+
+        @collection_options = {
+          checked: [checked, selected, polymorphic_value, value].find { |value| value != nil },
+          selected: [selected, checked, polymorphic_value, value].find { |value| value != nil },
+          include_blank: include_blank
+        }.compact
+      end
+
+      def html_options
+        # Not sure why I need this. But they're merged in if I don't.
+        options[:input].merge(skip_default_ids: nil, allow_method_names_outside_object: nil)
+      end
+
+      def value_method
+        @value_method ||= options[:input].delete(:value_method)
+      end
+
+      def label_method
+        @label_method ||= options[:input].delete(:label_method)
+      end
+
+      def group_method
+        @group_method ||= options[:input].delete(:group_method)
+      end
+
+      def group_label_method
+        @group_label_method ||= options[:input].delete(:group_label_method)
+      end
+
+      def option_key_method
+        @option_key_method ||= options[:input].delete(:option_key_method)
+      end
+
+      def option_value_method
+        @option_value_method ||= options[:input].delete(:option_value_method)
+      end
+
+      def options_collection
+        @options_collection || []
+      end
+
+      # This is a grouped polymorphic collection
+      # [["Clinics", [["Clinc 50", "Clinic_50"], ["Clinic 43", "Clinic_43"]]], ["Contacts", [["Contact 544", "Contact_544"]]]]
+      def assign_options_collection!
+        collection = options[:input].delete(:collection) || raise('Please include a collection')
+
+        grouped = collection.kind_of?(Hash) && collection.values.first.respond_to?(:to_a)
+
+        if grouped? && !grouped && collection.present?
+          raise "Grouped collection expecting a Hash {'Posts' => Post.all, 'Events' => Event.all} or a Hash {'Posts' => [['Post A', 1], ['Post B', 2]], 'Events' => [['Event A', 1], ['Event B', 2]]}"
+        end
+
+        if polymorphic? && !grouped && collection.present?
+          raise "Polymorphic collection expecting a Hash {'Posts' => Post.all, 'Events' => Event.all}"
+        end
+
+        @options_collection = (
+          if polymorphic?
+            collection.inject({}) { |h, (k, group)| h[k] = translate(group).map { |obj| [obj.to_s, "#{obj.class.model_name}_#{obj.id}"] }; h }
+          elsif grouped
+            collection.inject({}) { |h, (k, group)| h[k] = translate(group).map { |obj| obj }; h }
+          else
+            translate(collection).map { |obj| obj }
+          end
+        )
+      end
+
+      # Apply ActsAsArchived behavior. That's all for now.
+      def translate(collection)
+        return collection unless object.respond_to?(:new_record?)
+        return collection unless collection.respond_to?(:klass)
+
+        if collection.klass.respond_to?(:acts_as_archived?)
+          collection = if object.new_record?
+            collection.unarchived
+          else
+            collection.unarchived.or(collection.archived.where(collection.klass.primary_key => value))
+          end
+        end
+
+        if respond_to?(:ajax?) && ajax? # effective_select
+          collection = collection.where(collection.klass.primary_key => value)
+        end
+
+        collection
+      end
+
+      def assign_options_collection_methods!
+        options[:input].reverse_merge!(
+          if polymorphic?
+            { group_method: :last, group_label_method: :first, option_key_method: :second, option_value_method: :first }
+          elsif grouped?
+            first = Array(options_collection.values.first).first
+
+            if first.kind_of?(ActiveRecord::Base)
+              { group_method: :last, group_label_method: :first, option_value_method: :to_s, option_key_method: :id }
+            else
+              { group_method: :last, group_label_method: :first, option_value_method: :first, option_key_method: :second }
+            end
+          elsif options_collection.first.kind_of?(Array)
+            { label_method: :first, value_method: :second }
+          elsif options_collection.first.kind_of?(ActiveRecord::Base)
+            { label_method: :to_s, value_method: :id }
+          else
+            { label_method: :to_s, value_method: :to_s }
+          end
+        )
+      end
+
+      def polymorphic_type_method
+        name.to_s.sub('_id', '') + '_type'
+      end
+
+      def polymorphic_id_method
+        name.to_s.sub('_id', '') + '_id'
+      end
+
+      def polymorphic_value
+        return nil unless polymorphic?
+        "#{value.class.model_name}_#{value.id}" if value
+      end
+
+      def polymorphic_type_value
+        value.try(:class).try(:model_name)
+      end
+
+      def polymorphic_id_value
+        value.try(:id)
+      end
+
+    end
+  end
+end

data/app/models/effective/form_inputs/date_field.rb

@@ -0,0 +1,34 @@
+module Effective
+  module FormInputs
+    class DateField < DatetimeField
+
+      def input_html_options
+        {
+          class: ['form-control', 'effective_date_time_picker', 'effective_date', ('not-date-linked' if not_date_linked?)].compact.join(' '),
+          pattern: pattern
+        }
+      end
+
+      def input_js_options
+        { format: format, showTodayButton: false, showClear: false, useCurrent: 'hour', disabledDates: disabled_dates.presence, minDate: min_date.presence, maxDate: max_date.presence, locale: I18n.locale }.compact
+      end
+
+      def input_group_options
+        { input_group: { class: 'input-group effective_date_time_picker_input_group' }, prepend: content_tag(:span, icon('calendar'), class: 'input-group-text') }
+      end
+
+      def datetime_to_s # ruby
+        (value&.strftime('%F') rescue nil)
+      end
+
+      def pattern # html
+        '\d{4}(-\d{2})?(-\d{2})?'
+      end
+
+      def format # moment.js
+        'YYYY-MM-DD'
+      end
+
+    end
+  end
+end

data/app/models/effective/form_inputs/datetime_field.rb

@@ -0,0 +1,83 @@
+module Effective
+  module FormInputs
+    class DatetimeField < Effective::FormInput
+
+      def input_html_options
+        {
+          class: ['form-control', 'effective_date_time_picker', 'effective_datetime', ('not-date-linked' if not_date_linked?)].compact.join(' '),
+          pattern: pattern
+        }
+      end
+
+      def input_js_options
+        { format: format, sideBySide: true, showTodayButton: false, showClear: false, useCurrent: 'hour', disabledDates: disabled_dates.presence, minDate: min_date.presence, maxDate: max_date.presence, locale: I18n.locale }.compact
+      end
+
+      def input_group_options
+        { input_group: { class: 'input-group effective_date_time_picker_input_group' }, prepend: content_tag(:span, icon('calendar'), class: 'input-group-text') }
+      end
+
+      def build_input(&block)
+        @builder.super_text_field(name, options[:input].merge(value: datetime_to_s))
+      end
+
+      def datetime_to_s # ruby
+        (value&.strftime(am_pm? ? '%F %I:%M %p' : '%F %H:%M') rescue nil)
+      end
+
+      def pattern # html
+        am_pm? ? '\d{4}(-\d{2})?(-\d{2})?( \d{1,2})?(:\d{2} [aApPmM]{2})?' : '\d{4}(\-d{2})?(-\d{2})?( \d{2})?(:\d{2})?'
+      end
+
+      def format # moment.js
+        am_pm? ? 'YYYY-MM-DD LT' : 'YYYY-MM-DD HH:mm'
+      end
+
+      private
+
+      def disabled_dates
+        return @disabled_dates unless @disabled_dates.nil?
+        @disabled_dates ||= Array(options.delete(:disabledDates)).map { |obj| parse_object_date(obj) }.flatten.compact
+      end
+
+      def max_date
+        return @max_date unless @max_date.nil?
+        @max_date = parse_object_date(options.delete(:maxDate))
+      end
+
+      def min_date
+        return @min_date unless @min_date.nil?
+        @min_date = parse_object_date(options.delete(:minDate))
+      end
+
+      def not_date_linked?
+        return @not_date_linked unless @not_date_linked.nil?
+        @not_date_linked = (options.delete(:date_linked) == false)
+      end
+
+      def am_pm?
+        return @am_pm unless @am_pm.nil?
+        @am_pm = options.key?(:am_pm) ? options.delete(:am_pm) : true
+      end
+
+      private
+
+      def parse_object_date(obj)
+        if obj.respond_to?(:strftime)
+          (obj.strftime('%F') rescue nil)
+        elsif obj.kind_of?(Range) && obj.first.respond_to?(:strftime)
+          [obj.first].tap do |dates|
+            dates << (dates.last + 1.day) until (dates.last + 1.day) > obj.last
+          end
+        elsif obj.kind_of?(String)
+          obj
+        elsif obj.nil?
+          obj
+        else
+          raise "unexpected date object #{obj}. Expected a DateTime, Range of DateTimes or String"
+        end
+      end
+
+    end
+  end
+end