caring_form 1.2.3

data/gemfiles/rails_4.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~>4.0.0"
+
+gemspec :path=>"../"

data/gemfiles/rails_4_1.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 4.1.1"
+gem "simple_form", "~> 3.1.0.rc1"
+
+gemspec :path=>"../"

data/lib/caring_form.rb

@@ -0,0 +1,20 @@
+require "caring_form/version"
+require 'caring_form/simple_form/initializer'
+require 'caring_form/simple_form/monkey_patching'
+require 'caring_form/active_model/monkey_patching'
+
+if defined?(Rails)
+  require 'caring_form/engine'
+  require "webshims-rails"
+end
+
+module CaringForm
+  Error = Class.new(StandardError)
+end
+
+require 'caring_form/model'
+require 'caring_form/form_builder'
+require 'caring_form/action_view_extensions/form_helper'
+require 'caring_form/action_view_extensions/builder'
+require 'caring_form/action_view_extensions/config'
+require 'caring_form/action_view_extensions/flash_error_helper'

data/lib/caring_form/action_view_extensions/builder.rb

@@ -0,0 +1,75 @@
+module CaringForm
+  module ActionViewExtensions
+    module Builder
+      def collection_caring_radio(*args)
+        collection_caring(:radio_button, *args)
+      end
+
+      def collection_caring_check(attribute, collection, value, text, options = {}, html_options = {})
+        if html_options[:required] && options[:collection] && options[:collection].length > 1
+          html_options.delete(:required)
+          html_options[:class] = "group-required #{html_options[:class]}".strip
+        end
+
+        collection_caring(:check_box, attribute, collection, value, text, options, html_options)
+      end
+
+      private
+
+      def collection_caring(input_helper, attribute, collection, value_method, text_method, options={}, html_options={})
+        collection.inject('') do |result, item|
+          value = item.send value_method
+          text  = item.send text_method
+
+          default_html_options = begin
+            if self.respond_to? :default_html_options_for_collection
+              default_html_options_for_collection(item, value, options, html_options)
+            else
+              @default_options.merge(html_options)
+            end
+          end
+
+          label_options = {:class => 'rhs'}
+
+          if default_html_options.has_key?(:id)
+            value = value.gsub(/\s+/, '').underscore
+            default_html_options[:id] = "#{default_html_options[:id]}_#{value}"
+            label_options[:for] = default_html_options[:id]
+            label_name = nil
+          else
+            label_name = "#{attribute}_#{value}"
+          end
+
+          html = if input_helper == :radio_button
+                   radio_button(attribute, value, default_html_options)
+                 else
+                   default_html_options[:multiple] = true
+                   check_box(attribute, default_html_options, value, '')
+                 end
+          result << html
+          result << if label_name.nil?
+                      label(:not_used, text, label_options)
+                    else
+                      label(label_name, text, label_options)
+                    end
+          result << '<br />'.html_safe
+        end
+      end
+    end
+  end
+end
+
+ActionView::Helpers::FormBuilder.send :include, CaringForm::ActionViewExtensions::Builder
+
+require 'simple_form'
+module SimpleForm
+  class FormBuilder
+    if defined?(SimpleForm::Inputs::CollectionRadioButtonsInput)
+      map_type :caring_radio, :to => SimpleForm::Inputs::CollectionRadioButtonsInput
+      map_type :caring_check, :to => SimpleForm::Inputs::CollectionCheckBoxesInput
+    else
+      map_type :caring_radio, :to => SimpleForm::Inputs::CollectionInput
+      map_type :caring_check, :to => SimpleForm::Inputs::CollectionInput
+    end
+  end
+end

data/lib/caring_form/action_view_extensions/config.rb

@@ -0,0 +1,4 @@
+# don't render those field_with_error wrappers
+ActionView::Base.field_error_proc = Proc.new do |html_tag, instance|
+  html_tag
+end

data/lib/caring_form/action_view_extensions/flash_error_helper.rb

@@ -0,0 +1,28 @@
+module CaringForm
+  module ActionViewExtensions
+    module FlashErrorHelper
+      def caring_form_errors_for(form)
+        return '' if form.valid?
+        header, message = form.error_config.values_at(:header, :message)
+
+        content_tag(:div, :class => 'flash error') do
+          content_tag(:h2, header) +
+          content_tag(:div, :class => 'flash-close') do
+            content_tag(:a, "Close", :href => 'javascript:void(0)')
+          end +
+          content_tag(:div, :class => 'message') do
+            message.html_safe + content_tag(:ul) do
+              form.errors.values.flatten.map do |error_message|
+                content_tag(:li, error_message)
+              end.join.html_safe
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+if defined?(ActionView)
+  ActionView::Base.send :include, CaringForm::ActionViewExtensions::FlashErrorHelper
+end

data/lib/caring_form/action_view_extensions/form_helper.rb

@@ -0,0 +1,33 @@
+# TODO: be more flexible for URL generation (set form object #to_param, #persisted?, etc... to rely on rails conventions)
+module CaringForm
+  module ActionViewExtensions
+    module FormHelper
+      def caring_form_for(form_object, *args, &block)
+        block ||= proc {}
+        options = args.extract_options!
+        options[:builder] = CaringForm::FormBuilder
+        options[:url] = options.fetch(:url) do
+          form_object.url.present? ? form_object.url : url_for(params)
+        end
+        options[:html] ||= {}
+        options[:html][:class] = class_value(form_object, options[:html][:class])
+        options[:html][:id] ||= form_object.id unless form_object.id.nil?
+        args << options
+        form_for(form_object, *args, &block)
+      end
+
+      private
+
+      def class_value(form, extra_classes)
+        classes = %w(caring-form form-text simple_form)
+        classes.push(form.classes) if form.classes.present?
+        classes.push(extra_classes) if extra_classes.present?
+        classes.join(' ')
+      end
+    end
+  end
+end
+
+if defined?(ActionView)
+  ActionView::Base.send :include, CaringForm::ActionViewExtensions::FormHelper
+end

data/lib/caring_form/active_model/monkey_patching.rb

@@ -0,0 +1,32 @@
+require 'active_model'
+
+if ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR == 0
+
+  require 'active_model/validations/inclusion'
+
+  # backport inclusion validation from v3.1+ where :in can be a lambda/proc
+  class ActiveModel::Validations::InclusionValidator
+    ERROR_MESSAGE = "An object with the method #include? or a proc or lambda is required, " <<
+                    "and must be supplied as the :in option of the configuration hash"
+
+    def check_validity!
+      unless [:include?, :call].any?{ |method| options[:in].respond_to?(method) }
+        raise ArgumentError, ERROR_MESSAGE
+      end
+    end
+
+    def validate_each(record, attribute, value)
+      delimiter = options[:in]
+      exclusions = delimiter.respond_to?(:call) ? delimiter.call(record) : delimiter
+      unless exclusions.send(inclusion_method(exclusions), value)
+        record.errors.add(attribute, :inclusion, options.except(:in).merge!(:value => value))
+      end
+    end
+
+  private
+
+    def inclusion_method(enumerable)
+      enumerable.is_a?(Range) ? :cover? : :include?
+    end
+  end
+end

data/lib/caring_form/dsl.rb

@@ -0,0 +1,91 @@
+require 'caring_form/field_container'
+
+module CaringForm
+  module Dsl
+    def self.included(klass)
+      klass.instance_eval do
+        include CaringForm::FieldContainer
+        extend ClassMethods
+      end
+    end
+
+    def autofocus?(name)
+      self.class.autofocus == name
+    end
+
+    def index_on
+      return nil unless (index_name = self.class.index_on)
+      return nil unless respond_to?(index_name)
+      value = send(index_name)
+      value.present? ? value : nil
+    end
+
+    def spam?
+      self.class.can_check_spam? && reference.present?
+    end
+
+    def attributes(options = {})
+      keys = if options.has_key?(:except)
+               except = options[:except]
+               field_names do |name, field|
+                 except.none? { |key, value| field[key] == value }
+               end
+             else
+               field_names
+             end
+      keys.each_with_object({}) do |key, hash|
+        next unless respond_to?(key)
+        value = send(key)
+        hash[key.to_sym] = value unless value.nil?
+      end
+    end
+
+    def error_config
+      self.class.error_config
+    end
+
+    module ClassMethods
+      [:autofocus, :index_on, :id, :url, :classes].each do |variable|
+        variable_name = :"@#{variable}"
+        define_method(variable) do |*names|
+          instance_variable_set(variable_name, names.first) unless names.empty?
+          instance_variable_get(variable_name)
+        end
+      end
+
+      def protect_from_bots
+        dummy(:reference, :ancillary => true)
+        @can_check_spam = true
+      end
+
+      def can_check_spam?
+        @can_check_spam == true
+      end
+
+      def on_error(options = {})
+        @error_config = options.slice(:header, :message)
+      end
+
+      def error_config
+        @error_config ||= {
+          :header => "Sorry, this operation failed",
+          :message => "Please fix the errors below and try again."
+        }
+      end
+
+      def method_missing(meth, *args, &blk)
+        if CaringForm::FieldContainer::field_for(meth)
+          singleton = (class << self; self; end)
+          singleton.send(:define_method, meth) do |*meth_args|
+            options = meth_args.extract_options!.merge(:type => meth)
+            meth_args << nil if meth_args.empty? # set name to nil if no name
+            field(*(meth_args << options))
+          end
+          send(meth, *args)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/caring_form/engine.rb

@@ -0,0 +1,4 @@
+module CaringForm
+  class Engine < Rails::Engine
+  end
+end

data/lib/caring_form/field/base.rb

@@ -0,0 +1,145 @@
+# TODO: remove :wrapper that's only used to wrap a submit (use wrapper_tag instead?)
+# TODO: replace :required_message with a more generic way of overriding built-in field validation messages
+# TODO: allow to override validation message in the UI (warning: many validation rules on server side but only one validation message on client side)
+# TODO: document the API: which fields accept which options?
+# TODO: move non generic fields to their own place (looking_for, us_zip_code, etc...)
+# TODO: make sure we pass through all options we don't handle to simple_form so caring_form builder is a subset of simple_form builder
+# TODO: make sure we have a clear pattern to override field defaults, field declaration (form object) and field options (view) and that we use it everywhere
+# TODO: use locale to store default messages such as default validation messages
+
+require 'caring_form/tools/referee'
+
+module CaringForm
+  module Field
+    def self.field_attributes
+      [
+        :type, :hint, :optional, :label, :pattern, :remote_validator,
+        :collection, :wrapper, :wrapper_tag, :wrapper_html, :input_html,
+        :input_tag, :label_html, :ancillary, :primary, :prompt, :as, :if,
+        :required_message, :value
+      ]
+    end
+
+    Base = Struct.new(:name, *CaringForm::Field.field_attributes) do
+      def self.register(type)
+        CaringForm::FieldContainer.register_field(self, type)
+      end
+
+      def initialize(*args)
+        super
+
+        self.type             ||= :string
+        self.optional         ||= false
+        self.input_tag        ||= 'input'
+        self.wrapper_tag      ||= 'li'
+        self.wrapper_html     ||= {}
+        self.input_html       ||= {}
+        self.label_html       ||= {}
+        self.ancillary        ||= false
+        self.required_message ||= "Enter the #{name.to_s.humanize.downcase}"
+
+        self.label = default_label if self.label.nil?
+
+        @referee = Tools::Referee.new(self)
+      end
+
+      def apply_to_model(klass)
+        klass.send(:attr_accessor, name)
+        options = {:message => required_message}
+        if @referee.is_rule?(:optional)
+          referee = @referee
+          options[:if] = lambda do |form|
+            !referee.decide(:optional, form)
+          end
+          klass.send(:validates_presence_of, name, options)
+        elsif !optional
+          options[:if] = self.if if self.if.present?
+          klass.send(:validates_presence_of, name, options)
+        end
+      end
+
+      def input_properties(form, options = {})
+        options = normalize_options(form, options)
+        req = {
+          :as           => options.fetch(:as, simple_type),
+          :collection   => options.fetch(:collection, collection),
+          :prompt       => options.fetch(:prompt, prompt),
+          :label        => options.fetch(:label, label),
+          :wrapper      => options.fetch(:wrapper, wrapper),
+          :wrapper_tag  => options.fetch(:wrapper_tag, wrapper_tag),
+          :wrapper_html => options.fetch(:wrapper_html, wrapper_html).merge(:class => 'field'),
+          :input_html   => options.fetch(:input_html, input_html),
+          :label_html   => options.fetch(:label_html, label_html)
+        }
+        req[:input_html][:autofocus] = 'autofocus' if form.autofocus?(name)
+        req[:input_html][:title] ||= required_message if required_message.present?
+        if form.errors[self.name].present?
+          req[:wrapper_html][:class] = "field-with-errors #{req[:wrapper_html][:class]}".rstrip
+        end
+
+        if form.index_on.present?
+          req[:label_html][:index] = req[:input_html][:index] = form.index_on
+        end
+        if @referee.decide(:optional, form)
+          req[:required] = false
+        else
+          req[:input_html][:required] = 'required'
+        end
+        req[:input_html].merge!(@referee.rule_as_data_attribute(:optional, form))
+        req[:input_html][:name] = name if ancillary
+        set_hint!(req)
+        set_remote_validator!(req)
+        req.deep_merge!(options)
+      end
+
+      def simple_type
+        raise "override me!"
+      end
+
+      def default_label
+        self.name.to_s.humanize.titleize
+      end
+
+      def render(form, builder, options = {})
+        properties = input_properties(form, options)
+        if properties[:generate] == false
+          ''
+        else
+          properties[:required] = true unless optional
+          builder.input(name, properties)
+        end
+      end
+
+      private
+
+      def normalize_options(form, options)
+        options = options.dup
+        [:label, :collection].each do |name|
+          value = options.fetch(name, send(name))
+          options[name] = form.send(value) if value.is_a?(Symbol)
+        end
+        if_value = options.fetch(:if, self.if)
+        options[:generate] = form.send(if_value) if if_value.is_a?(Symbol)
+        options
+      end
+
+      def set_hint!(req)
+        return unless hint.present?
+        req[:hint] = hint
+      end
+
+      def set_remote_validator!(req)
+        return unless remote_validator.present?
+        req[:as] = :string_inline_error
+        url, idle = if remote_validator.respond_to?(:values_at)
+                      remote_validator.values_at(:url, :idle_time)
+                    else
+                      [remote_validator, nil]
+                    end
+        req[:input_html][:'data-validator-url'] = url
+        req[:input_html][:'data-max-idle-time'] = idle if idle
+        req[:input_html][:class] = "validate-remotely #{req[:input_html][:class]}".strip
+      end
+    end
+  end
+end