effective_bootstrap 0.0.1

data/app/assets/stylesheets/effective_time/input.scss

@@ -0,0 +1 @@
+@import '../effective_datetime/input';

data/app/helpers/effective_bootstrap_helper.rb

@@ -0,0 +1,52 @@
+# Boostrap4 Helpers
+
+module EffectiveBootstrapHelper
+  # Nav links and dropdowns
+  # Automatically puts in the 'active' class based on request path
+
+  # %ul.navbar-nav
+  #   = nav_link_to 'Sign In', new_user_session_path
+  #   = nav_dropdown 'Settings' do
+  #     = nav_link_to 'Account Settings', user_settings_path
+  #     = nav_dropdown_divider
+  #     = nav_link_to 'Sign In', new_user_session_path, method: :delete
+  def nav_link_to(label, path, opts = {})
+    if @_nav_mode == :dropdown  # We insert dropdown-items
+      return link_to(label, path, merge_class_key(opts, 'dropdown-item'))
+    end
+
+    # Regular nav link item
+    content_tag(:li, class: (request.fullpath.include?(path) ? 'nav-item active' : 'nav-item')) do
+      link_to(label, path, merge_class_key(opts, 'nav-link'))
+    end
+  end
+
+  def nav_dropdown(label, right: false, link_class: [], list_class: [], &block)
+    raise 'expected a block' unless block_given?
+
+    id = "dropdown-#{''.object_id}"
+
+    content_tag(:li, class: 'nav-item dropdown') do
+      content_tag(:a, class: 'nav-link dropdown-toggle', href: '#', id: id, role: 'button', 'data-toggle': 'dropdown', 'aria-haspopup': true, 'aria-expanded': false) do
+        label.html_safe
+      end + content_tag(:div, class: (right ? 'dropdown-menu dropdown-menu-right' : 'dropdown-menu'), 'aria-labelledby': id) do
+        @_nav_mode = :dropdown; yield; @_nav_mode = nil
+      end
+    end
+  end
+
+  def nav_divider
+    content_tag(:div, '', class: 'dropdown-divider')
+  end
+
+  def merge_class_key(hash, value)
+    return { :class => value } unless hash.kind_of?(Hash)
+
+    if hash[:class].present?
+      hash.merge!(:class => "#{hash[:class]} #{value}")
+    else
+      hash.merge!(:class => value)
+    end
+  end
+
+end

data/app/helpers/effective_form_builder_helper.rb

@@ -0,0 +1,23 @@
+module EffectiveFormBuilderHelper
+  def effective_form_with(**options, &block)
+    options[:class] = [options[:class], 'needs-validation', ('form-inline' if options[:layout] == :inline)].compact.join(' ')
+
+    without_error_proc do
+      form_with(**options.merge(builder: Effective::FormBuilder, html: { novalidate: true, onsubmit: 'return EffectiveBootstrap.validate(this);' }), &block)
+    end
+  end
+
+  private
+
+  # Disables a .fields_with_errors wrapping div when
+  def without_error_proc
+    original = ActionView::Base.field_error_proc
+
+    begin
+      ActionView::Base.field_error_proc = proc { |input, _| input }; yield
+    ensure
+      ActionView::Base.field_error_proc = original
+    end
+  end
+
+end

data/app/helpers/effective_icons_helper.rb

@@ -0,0 +1,46 @@
+module EffectiveIconsHelper
+
+  def icon(svg, options = {})
+    svg = svg.to_s.chomp('.svg')
+
+    options.reverse_merge!(nocomment: true)
+    options[:class] = [options[:class], "eb-icon eb-icon-#{svg}"].compact.join(' ')
+
+    inline_svg(svg + '.svg', options)
+  end
+
+  def icon_to(svg, url, options = {})
+    link_to(icon(svg), url, options)
+  end
+
+  def show_icon_to(path, options = {})
+    icon_to('eye-open', path, { title: 'Show' }.merge(options))
+  end
+
+  def edit_icon_to(path, options = {})
+    icon_to('edit', path, { title: 'Edit' }.merge(options))
+  end
+
+  def destroy_icon_to(path, options = {})
+    defaults = { title: 'Destroy', data: { method: :delete, confirm: 'Delete this item?' } }
+    icon_to('trash', path, defaults.merge(options))
+  end
+
+  def settings_icon_to(path, options = {})
+    icon_to('cog', path, { title: 'Settings' }.merge(options))
+  end
+
+  def ok_icon_to(path, options = {})
+    icon_to('ok', path, { title: 'OK' }.merge(options))
+  end
+
+  def approve_icon_to(path, options = {})
+    icon_to('ok', path, { title: 'Approve' }.merge(options))
+  end
+
+  def remove_icon_to(path, options = {})
+    icon_to('remove', path, { title: 'Remove' }.merge(options))
+  end
+
+end
+

data/app/models/effective/access_denied.rb

@@ -0,0 +1,17 @@
+unless defined?(Effective::AccessDenied)
+  module Effective
+    class AccessDenied < StandardError
+      attr_reader :action, :subject
+
+      def initialize(message = nil, action = nil, subject = nil)
+        @message = message
+        @action = action
+        @subject = subject
+      end
+
+      def to_s
+        @message || I18n.t(:'unauthorized.default', :default => 'Access Denied')
+      end
+    end
+  end
+end

data/app/models/effective/form_builder.rb

@@ -0,0 +1,100 @@
+module Effective
+  class FormBuilder < ActionView::Helpers::FormBuilder
+
+    attr_accessor :layout, :template
+
+    delegate :content_tag, to: :template
+
+    def initialize(object_name, object, template, options)
+      @template = template
+      @layout = (options.delete(:layout) || :vertical).to_sym
+      super
+    end
+
+    alias_method :super_text_field, :text_field
+
+    def check_box(name, options = {})
+      Effective::FormInputs::CheckBox.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def checks(name, choices = nil, *args)
+      options = args.extract_options!.merge!(collection: choices)
+      Effective::FormInputs::Checks.new(name, options, builder: self).to_html
+    end
+
+    def date_field(name, options = {})
+      Effective::FormInputs::DateField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def datetime_field(name, options = {})
+      Effective::FormInputs::DatetimeField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def email_field(name, options = {})
+      Effective::FormInputs::EmailField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def error(name = nil, options = {})
+      Effective::FormInputs::ErrorField.new(name, options, builder: self).to_html()
+    end
+    alias_method :errors, :error
+
+    def form_group(name = nil, options = {}, &block)
+      Effective::FormInputs::FormGroup.new(name, options, builder: self).to_html(&block)
+    end
+
+    def number_field(name, options = {})
+      Effective::FormInputs::NumberField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def password_field(name, options = {})
+      Effective::FormInputs::PasswordField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def phone_field(name, options = {})
+      Effective::FormInputs::PhoneField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+    alias_method :tel_field, :phone_field
+    alias_method :telephone_field, :phone_field
+
+    def price_field(name, options = {})
+      Effective::FormInputs::PriceField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def select(name, choices = nil, *args)
+      options = args.extract_options!.merge!(collection: choices)
+      Effective::FormInputs::Select.new(name, options, builder: self).to_html
+    end
+
+    def submit(name = 'Submit', options = {})
+      Effective::FormInputs::Submit.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def static_field(name, options = {}, &block)
+      Effective::FormInputs::StaticField.new(name, options, builder: self).to_html(&block)
+    end
+
+    def radios(name, choices = nil, *args)
+      options = args.extract_options!.merge!(collection: choices)
+      Effective::FormInputs::Radios.new(name, options, builder: self).to_html
+    end
+
+    def text_area(name, options = {})
+      Effective::FormInputs::TextArea.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def text_field(name, options = {})
+      Effective::FormInputs::TextField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def time_field(name, options = {})
+      Effective::FormInputs::TimeField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def url_field(name, options = {})
+      Effective::FormInputs::UrlField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+  end
+end
+

data/app/models/effective/form_input.rb

@@ -0,0 +1,319 @@
+module Effective
+  class FormInput
+    attr_accessor :name, :options
+
+    BLANK = ''.html_safe
+
+    delegate :object, to: :@builder
+    delegate :capture, :content_tag, :link_to, :icon, to: :@template
+
+    # So this takes in the options for an entire form group.
+    def initialize(name, options, builder:, html_options: nil)
+      @builder = builder
+      @template = builder.template
+
+      @name = name
+      @options = extract_options!(options, html_options: html_options)
+      apply_input_options!
+    end
+
+    def input_group_options
+      { input_group: { class: 'input-group' }, prepend: false, append: false }
+    end
+
+    def input_html_options
+      { class: 'form-control' }
+    end
+
+    def input_js_options
+      {}
+    end
+
+    def label_options
+      case layout
+      when :horizontal
+        { class: 'col-sm-2 col-form-label'}
+      when :inline
+        { class: 'sr-only' }
+      else
+        { }
+      end
+    end
+
+    def feedback_options
+      case layout
+      when :inline
+        false
+      else
+        { valid: { class: 'valid-feedback' }, invalid: { class: 'invalid-feedback' } }
+      end
+    end
+
+    def hint_options
+      case layout
+      when :inline
+        { tag: :small, class: 'text-muted', id: "#{tag_id}_hint" }
+      else
+        { tag: :small, class: 'form-text text-muted', id: "#{tag_id}_hint" }
+      end
+    end
+
+    def wrapper_options
+      case layout
+      when :horizontal
+        { class: 'form-group row' }
+      else
+        { class: 'form-group' }
+      end
+    end
+
+    def to_html(&block)
+      wrap(&block)
+    end
+
+    protected
+
+    def wrap(&block)
+      case layout
+      when :inline
+        build_content(&block)
+      when :horizontal
+        build_wrapper do
+          (build_label.presence || content_tag(:div, '', class: 'col-sm-2')) +
+          content_tag(:div, build_content(&block), class: 'col-sm-10')
+        end
+      else # Vertical
+        build_wrapper { build_content(&block) }
+      end.html_safe
+    end
+
+    def build_wrapper(&block)
+      content_tag(:div, yield, options[:wrapper])
+    end
+
+    def build_content(&block)
+      return build_input_group_content(&block) if input_group?
+
+      if layout == :horizontal
+        build_input(&block) + build_feedback + build_hint
+      else
+        build_label + build_input(&block) + build_feedback + build_hint
+      end
+    end
+
+    def build_input_group_content(&block)
+      if layout == :horizontal
+        build_input_group { build_input(&block) } + build_hint
+      else
+        build_label + build_input_group { build_input(&block) } + build_hint
+      end
+    end
+
+    def build_input_group(&block) # Includes input and feedback
+      content_tag(:div, '', options[:input_group][:input_group]) do # Twice here, kind of weird.
+        [
+          (content_tag(:div, options[:input_group][:prepend], class: 'input-group-prepend') if options[:input_group][:prepend]),
+          build_input(&block),
+          (content_tag(:div, options[:input_group][:append], class: 'input-group-append') if options[:input_group][:append]),
+          build_feedback
+        ].compact.join.html_safe
+      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
+
+      if options[:input][:id]
+        options[:label][:for] = options[:input][:id]
+      end
+
+      @builder.label(name, text, options[:label])
+    end
+
+    def build_input(&block)
+      capture(&block)
+    end
+
+    def build_hint
+      return BLANK unless options[:hint] && options[:hint][:text]
+
+      tag = options[:hint].delete(:tag)
+      text = options[:hint].delete(:text).html_safe
+
+      content_tag(tag, text, options[:hint])
+    end
+
+    def build_feedback
+      return BLANK if options[:feedback] == false
+
+      invalid = object.errors[name].to_sentence.presence if object.respond_to?(:errors)
+      invalid ||= options[:feedback][:invalid].delete(:text)
+      invalid ||= [("can't be blank" if options[:input][:required]), ('must be valid' if validated?(name))].compact.join(' and ')
+      invalid ||= 'is invalid'
+
+      valid = options[:feedback][:valid].delete(:text) || "Look's good!"
+
+      content_tag(:div, invalid, options[:feedback][:invalid]) +
+      content_tag(:div, valid, options[:feedback][:valid])
+    end
+
+    def has_error?(name = nil)
+      return false unless object.respond_to?(:errors)
+      name ? object.errors[name].present? : object.errors.present?
+    end
+
+    def required?(name)
+      return false unless object && name
+
+      obj = (object.class == Class) ? object : object.class
+      return false unless obj.respond_to?(:validators_on)
+
+      obj.validators_on(name).any? { |v| v.kind_of?(ActiveRecord::Validations::PresenceValidator) }
+    end
+
+    def validated?(name)
+      return false unless object && name
+
+      obj = (object.class == Class) ? object : object.class
+      return false unless obj.respond_to?(:validators_on)
+
+      obj.validators_on(name).any? { |v| !v.kind_of?(ActiveRecord::Validations::PresenceValidator) }
+    end
+
+    def input_group?
+      (options[:input_group][:append] || options[:input_group][:prepend]).present?
+    end
+
+    # Used for passwords and to not apply server side feedback
+    def reset_feedback?
+      return @reset_feedback unless @reset_feedback.nil?
+      @reset_feedback = options[:feedback].present? && (options[:feedback].delete(:reset) == true)
+    end
+
+    def value
+      object.public_send(name) if object.respond_to?(name)
+    end
+
+    private
+
+    # Here we split them into { wrapper: {}, label: {}, hint: {}, input: {} }
+    # And make sure to keep any additional options on the input: {}
+    def extract_options!(options, html_options: nil)
+      options.symbolize_keys!
+      html_options.symbolize_keys! if html_options
+
+      # effective_bootstrap specific options
+      layout = options.delete(:layout) # Symbol
+      wrapper = options.delete(:wrapper) # Hash
+      input_group = { append: options.delete(:append), prepend: options.delete(:prepend), input_group: options.delete(:input_group) }.compact
+
+      feedback = options.delete(:feedback) # Hash
+      label = options.delete(:label) # String or Hash
+      hint = options.delete(:hint) # String or Hash
+
+      input_html = options.delete(:input_html) || {} # Hash
+      input_js = options.delete(:input_js) || {} # Hash
+
+      # Every other option goes to input
+      @options = input = (html_options || options)
+
+      # Merge all the default objects, and intialize everything
+      wrapper = merge_defaults!(wrapper, wrapper_options)
+      input_group = merge_defaults!(input_group, input_group_options)
+      feedback = merge_defaults!(feedback, feedback_options)
+
+      label = merge_defaults!(label, label_options)
+      hint = merge_defaults!(hint, hint_options)
+
+      # Merge input_html: {}, defaults, and add all class: keys together
+      input.merge!(input_html.except(:class))
+      merge_defaults!(input, input_html_options.except(:class))
+      input[:class] = [input[:class], input_html[:class], input_html_options[:class]].compact.join(' ')
+
+      merge_defaults!(input_js, input_js_options)
+
+      if input_js.present?
+        merge_defaults!(input_js, input_js_options_method_name)
+        input['data-input-js-options'] = JSON.generate(input_js)
+      end
+
+      { layout: layout, wrapper: wrapper, input_group: input_group, label: label, hint: hint, input: input, feedback: feedback }
+    end
+
+    def apply_input_options!
+      # Server side validation
+      if has_error?
+        if has_error?(name)
+          options[:input][:class] = [options[:input][:class], 'is-invalid'].compact.join(' ')
+        elsif reset_feedback?
+          # Nothing
+        else
+          options[:input][:class] = [options[:input][:class], 'is-valid'].compact.join(' ')
+        end
+      end
+
+      if required?(name) && (options[:input].delete(:required) != false)
+        options[:input][:required] = 'required'
+      end
+
+      if options[:input][:readonly]
+        options[:input][:readonly] = 'readonly'
+        options[:input][:class] = options[:input][:class].to_s.sub('form-control', 'form-control-plaintext')
+      end
+
+      if options[:hint] && options[:hint][:text] && options[:hint][:id]
+        options[:input].reverse_merge!('aria-describedby': options[:hint][:id])
+      end
+    end
+
+    def merge_defaults!(obj, defaults)
+      defaults = {} if defaults.nil?
+
+      case obj
+      when false
+        false
+      when nil, true
+        defaults
+      when String
+        defaults.merge(text: obj)
+      when Hash
+        obj.reverse_merge!(defaults)
+      else
+        raise 'unexpected object'
+      end
+    end
+
+    def layout
+      options[:layout] || @builder.layout
+    end
+
+    # https://github.com/rails/rails/blob/master/actionview/lib/action_view/helpers/tags/base.rb#L120
+    # Not 100% sure best way to generate this
+    def tag_id(index = nil)
+      case
+      when @builder.object_name.empty?
+        sanitized_method_name.dup
+      when index
+        "#{sanitized_object_name}_#{index}_#{sanitized_method_name}"
+      else
+        "#{sanitized_object_name}_#{sanitized_method_name}"
+      end
+    end
+
+    def sanitized_object_name
+      @builder.object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "")
+    end
+
+    def sanitized_method_name
+      name.to_s.sub(/\?$/, "")
+    end
+
+    def input_js_options_method_name
+      { method_name: "effective_#{self.class.name.split('::').last.underscore.chomp('_field')}" }
+    end
+
+  end
+end