effective_bootstrap 0.7.3

data/app/helpers/effective_icons_helper.rb

@@ -0,0 +1,51 @@
+module EffectiveIconsHelper
+
+  # icon('check', class: 'big-4')
+  # icon('check', class: 'small-3')
+  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_tag("icons/#{svg}.svg", options)
+  end
+
+  def icon_to(svg, url, options = {})
+    link_to(icon(svg), url, options)
+  end
+
+  def new_icon_to(path, options = {})
+    icon_to('plus', path, { title: 'New' }.merge(options))
+  end
+
+  def show_icon_to(path, options = {})
+    icon_to('eye', 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,199 @@
+module Effective
+  class FormBuilder < ActionView::Helpers::FormBuilder
+
+    attr_accessor :template, :layout, :action, :readonly, :disabled, :remote
+
+    delegate :content_tag, to: :template
+
+    def initialize(object_name, object, template, options)
+      @template = template
+
+      @layout = (options.delete(:layout) || :vertical).to_sym
+      @action = options.delete(:action)
+      @readonly = options.delete(:readonly)
+      @disabled = options.delete(:disabled)
+      @remote = options[:remote]
+
+      super
+    end
+
+    alias_method :super_number_field, :number_field
+    alias_method :super_text_field, :text_field
+    alias_method :super_text_area, :text_area
+
+    def clear(name = 'Clear', options = {})
+      (options = name; name = 'Clear') if name.kind_of?(Hash)
+      Effective::FormInputs::Clear.new(name, options, builder: self).to_html
+    end
+
+    def check_box(name, options = {})
+      Effective::FormInputs::CheckBox.new(name, options, builder: self).to_html {
+        checked_value = options.fetch(:checked_value, '1')
+        unchecked_value = options.fetch(:unchecked_value, '0')
+        super(name, options.except(:checked_value, :unchecked_value), checked_value, unchecked_value)
+      }
+    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 ck_editor(name, options = {}, &block)
+      Effective::FormInputs::CkEditor.new(name, options, builder: self).to_html(&block)
+    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 delete(name = 'Remove', url = nil, options = {}, &block)
+      options[:href] ||= url
+      Effective::FormInputs::Delete.new(name, options, builder: self).to_html(&block)
+    end
+
+    def editor(name, options = {}, &block)
+      Effective::FormInputs::Editor.new(name, options, builder: self).to_html(&block)
+    end
+
+    def email_field(name, options = {})
+      Effective::FormInputs::EmailField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def email_cc_field(name, options = {})
+      Effective::FormInputs::EmailCcField.new(name, options, builder: self).to_html
+    end
+
+    def error(name = nil, options = {})
+      Effective::FormInputs::ErrorField.new(name, options, builder: self).to_html()
+    end
+    alias_method :errors, :error
+
+    def file_field(name, options = {})
+      Effective::FormInputs::FileField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def float_field(name, options = {})
+      Effective::FormInputs::FloatField.new(name, options, builder: self).to_html
+    end
+
+    def form_group(name = nil, options = {}, &block)
+      Effective::FormInputs::FormGroup.new(name, options, builder: self).to_html(&block)
+    end
+
+    def integer_field(name, options = {})
+      Effective::FormInputs::IntegerField.new(name, options, builder: self).to_html
+    end
+
+    # This is gonna be a post?
+    def remote_link_to(name, url, options = {}, &block)
+      options[:href] ||= url
+      Effective::FormInputs::RemoteLinkTo.new(name, options, builder: self).to_html(&block)
+    end
+
+    def search_field(name, options = {})
+      Effective::FormInputs::SearchField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def number_field(name, options = {})
+      Effective::FormInputs::NumberField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def number_text_field(name, options = {})
+      Effective::FormInputs::NumberTextField.new(name, options, builder: self).to_html
+    end
+
+    def password_field(name, options = {})
+      Effective::FormInputs::PasswordField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    def percent_field(name, options = {})
+      Effective::FormInputs::PercentField.new(name, options, builder: self).to_html
+    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 save(name = 'Save', options = {})
+      (options = name; name = 'Save') if name.kind_of?(Hash)
+      Effective::FormInputs::Save.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 select_or_text(name, name_text, choices = nil, *args)
+      options = args.extract_options!.merge!(name_text: name_text, collection: choices)
+      Effective::FormInputs::SelectOrText.new(name, options, builder: self).to_html
+    end
+
+    def submit(name = 'Save', options = {}, &block)
+      (options = name; name = 'Save') if name.kind_of?(Hash)
+      Effective::FormInputs::Submit.new(name, options, builder: self).to_html(&block)
+    end
+
+    def static_field(name, options = {}, &block)
+      options = { value: options } if options.kind_of?(String)
+      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 reset(name = 'Reset', options = {})
+      (options = name; name = 'Reset') if name.kind_of?(Hash)
+      Effective::FormInputs::Reset.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 time_zone_select(name, options = {})
+      opts = options.merge(collection: Effective::FormInputs::TimeZoneSelect.time_zone_collection)
+      Effective::FormInputs::TimeZoneSelect.new(name, opts, builder: self).to_html
+    end
+
+    def url_field(name, options = {})
+      Effective::FormInputs::UrlField.new(name, options, builder: self).to_html { super(name, options) }
+    end
+
+    # Logics
+    def hide_if(*args, &block)
+      Effective::FormLogics::HideIf.new(*args, builder: self).to_html(&block)
+    end
+
+    def show_if(*args, &block)
+      Effective::FormLogics::ShowIf.new(*args, builder: self).to_html(&block)
+    end
+
+    def show_if_any(*args, &block)
+      Effective::FormLogics::ShowIfAny.new(*args, builder: self).to_html(&block)
+    end
+
+  end
+end
+

data/app/models/effective/form_input.rb

@@ -0,0 +1,434 @@
+module Effective
+  class FormInput
+    attr_accessor :name, :options
+
+    BLANK = ''.html_safe
+    EXCLUSIVE_CLASS_PREFIXES = [] # None
+    EXCLUSIVE_CLASS_SUFFIXES = ['-primary', '-secondary', '-success', '-danger', '-warning', '-info', '-light', '-dark']
+
+    delegate :object, to: :@builder
+    delegate :capture, :content_tag, :link_to, :icon, :asset_path, 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)
+      name_to_s = name.to_s
+
+      text ||= (
+        if object && name_to_s.ends_with?('_id')
+          object.class.human_attribute_name(name_to_s.chomp('_id'))
+        elsif object && name_to_s.ends_with?('_ids')
+          object.class.human_attribute_name(name_to_s.chomp('_ids').pluralize)
+        elsif object
+          object.class.human_attribute_name(name)
+        else
+          BLANK
+        end
+      )
+
+      if options[:input][:id]
+        options[:label][:for] = options[:input][:id]
+      end
+
+      @builder.label(name, text.html_safe, 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)
+
+      content_tag(tag, text.html_safe, 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).presence
+      invalid ||= [("can't be blank" if options[:input][:required]), ('must be valid' if validated?(name))].compact.join(' and ').presence
+      invalid ||= "can't be blank or is invalid"
+
+      valid = options[:feedback][:valid].delete(:text) || 'Looks good!'
+
+      content_tag(:div, invalid.html_safe, options[:feedback][:invalid]) +
+      content_tag(:div, valid.html_safe, options[:feedback][:valid])
+    end
+
+    def has_error?(name = nil)
+      return false unless object.respond_to?(:errors)
+
+      if name
+        object.errors[name].present? || (parent_object && parent_object.errors[name].present?)
+      else
+        object.errors.present? || parent_object&.errors&.present?
+      end
+    end
+
+    def required?(name)
+      return false unless object && name
+
+      obj = (object.class == Class) ? object : object.class
+      return false unless obj.respond_to?(:validators_on)
+
+      if name.to_s.ends_with?('_id')
+        return required_presence?(obj, name) || required_presence?(obj, name[0...-3])
+      end
+
+      required_presence?(obj, name)
+    end
+
+    def required_presence?(obj, name)
+      obj.validators_on(name).any? do |v|
+        (
+          v.kind_of?(ActiveRecord::Validations::PresenceValidator) ||
+          v.kind_of?(ActiveModel::Validations::AcceptanceValidator)
+        ) && required_options?(v.options)
+      end
+    end
+
+    def required_options?(opts)
+      return true unless (opts.key?(:if) || opts.key?(:unless))
+
+      if opts[:if].respond_to?(:call)
+        return object.instance_exec(&opts[:if])
+      end
+
+      if opts[:if].kind_of?(Symbol)
+        return object.send(opts[:if])
+      end
+
+      if opts.key?(:if)
+        return opts[:if]
+      end
+
+      if opts[:unless].respond_to?(:call)
+        return !object.instance_exec(&opts[:unless])
+      end
+
+      if opts[:unless].kind_of?(Symbol)
+        return !object.send(opts[:unless])
+      end
+
+      if opts.key?(:unless)
+        return !opts[:unless]
+      end
+
+      false
+    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? do |v|
+        !(v.kind_of?(ActiveRecord::Validations::PresenceValidator) || v.kind_of?(ActiveModel::Validations::AcceptanceValidator))
+      end
+    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
+      @_value ||= (options.delete(:value) || options[:input]&.delete(:value))
+      @_value ||= (object.public_send(name) if object.respond_to?(name))
+    end
+
+    def unique_id(item = nil)
+      if item && item.respond_to?(value_method)
+        item_value = (item.send(value_method).to_s.parameterize.presence rescue nil)
+      end
+
+      [tag_id, item_value, object_id].compact.join('_')
+    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_defaults!(input.merge!(input_html), input_html_options)
+      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 readonly?
+        options[:input][:readonly] = 'readonly'
+
+        unless options[:input][:class].to_s.include?('form-control-plaintext')
+          options[:input][:class] = options[:input][:class].to_s.sub('form-control', 'form-control-plaintext')
+        end
+      end
+
+      if disabled?
+        options[:input][:disabled] = 'disabled'
+      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
+        html_classes = (obj[:class].to_s.split(' ') + defaults[:class].to_s.split(' ')).uniq
+
+        # Try to smart merge bootstrap classes
+        if (exclusive = html_classes.select { |c| c.include?('-') }).length > 1
+          EXCLUSIVE_CLASS_PREFIXES.each do |prefix|
+            prefixed = exclusive.select { |c| c.start_with?(prefix) }
+            prefixed[1..-1].each { |c| html_classes.delete(c) } if prefixed.length > 1
+          end
+
+          suffixed = exclusive.select { |c| EXCLUSIVE_CLASS_SUFFIXES.any? { |suffix| c.end_with?(suffix) } }
+          suffixed[1..-1].each { |c| html_classes.delete(c) } if suffixed.length > 1
+        end
+
+        obj[:class] = html_classes.join(' ') if html_classes.present?
+        obj.reverse_merge!(defaults)
+        obj
+      else
+        defaults.merge(text: obj.to_s)
+      end
+    end
+
+    def layout
+      options[:layout] || @builder.layout
+    end
+
+    def form_readonly?
+      @builder.readonly
+    end
+
+    def readonly?
+      options.dig(:input, :readonly).present? || form_readonly?
+    end
+
+    def disabled?
+      options.dig(:input, :disabled).present? || form_disabled?
+    end
+
+    def form_disabled?
+      @builder.disabled
+    end
+
+    def form_remote?
+      @builder.remote
+    end
+
+    def parent_object
+      @builder.options[:parent_builder]&.object
+    end
+
+    # https://github.com/rails/rails/blob/master/actionview/lib/action_view/helpers/tags/base.rb#L120
+    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.downcase.parameterize
+    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