caring_form 1.2.3

data/lib/caring_form/field_container.rb

@@ -0,0 +1,126 @@
+module CaringForm
+  module FieldContainer
+    def self.register_field(klass, type)
+      @registered_fields ||= {}
+      @registered_fields[type] = klass
+    end
+
+    def self.field_for(type)
+      @registered_fields[type]
+    end
+
+    def self.custom_field_mapping
+      {
+        :full_name   => :string,
+        :email       => :string,
+        :tel         => :string,
+        :us_zip_code => :string,
+        :dummy       => :string,
+        :looking_for => :select,
+        :metadata    => :hidden
+      }
+    end
+
+    def self.included(klass)
+      klass.instance_eval do
+        extend ClassMethods
+        class << self
+          class_attribute :fields
+        end
+        self.fields = ActiveSupport::OrderedHash.new
+      end
+    end
+
+    def field_names(&block)
+      self.class.field_names(&block)
+    end
+
+    def field_definitions
+      self.class.fields.values.dup
+    end
+
+    def field_id(name)
+      if (field = self.class.fields[name])
+        id = field.input_html[:id] || default_field_id(field)
+      else
+        nil
+      end
+    end
+
+    def default_field_id(field)
+      [sanitized_form_name, index_on, field.name].compact.join('_')
+    end
+
+    def normalize_attribute_value(name, value)
+      return value unless (field = self.class.fields[name.to_sym])
+      case 
+      when field.type == :check_box && value.is_a?(Array)
+        value.last
+      else
+        value
+      end
+    end
+
+    private
+
+    def sanitized_form_name
+      underscored_form_name = self.class.model_name.to_s.underscore
+      underscored_form_name.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "")
+    end
+
+    module ClassMethods
+      def field(name, options = {})
+        if (not_supported = options.keys - CaringForm::Field.field_attributes).present?
+          raise Error.new("CaringForm::Dsl.field: #{not_supported.join(', ')} not supported")
+        end
+        supported_option_names = CaringForm::Field.field_attributes
+        values = options.values_at(*supported_option_names)
+        if options[:type] == :submit
+          field = new_field(:submit, *values)
+          field.properties = Array(name)
+          name = :submit
+        else
+          field = new_field(name, *values)
+          field.apply_to_model(self)
+        end
+        @fields[name.to_sym] = field
+      end
+
+      def field_names(&block)
+        real_fields = fields.reject { |_, field| field.kind_of?(CaringForm::Field::Submit) }
+        return real_fields.keys.map(&:to_s) unless block_given?
+        selected = real_fields.select(&block)
+        # ruby 1.8 returns an array, 1.9 returns a hash
+        keys = selected.is_a?(Array) ? selected.map(&:first) : selected.keys
+        keys.map(&:to_s)
+      end
+
+      def inherited(subclass)
+        subclass.fields = self.fields.dup
+      end
+
+      private
+
+      def new_field(name, type, *values)
+        klass = CaringForm::FieldContainer.field_for(type)
+        values.unshift(type)
+        klass.new(name, *values)
+      end
+    end
+  end
+end
+
+require 'caring_form/field/string'
+require 'caring_form/field/text'
+require 'caring_form/field/collection'
+require 'caring_form/field/looking_for'
+require 'caring_form/field/check_boxes'
+require 'caring_form/field/check_box'
+require 'caring_form/field/radio_buttons'
+require 'caring_form/field/metadata'
+require 'caring_form/field/full_name'
+require 'caring_form/field/email'
+require 'caring_form/field/tel'
+require 'caring_form/field/us_zip_code'
+require 'caring_form/field/dummy'
+require 'caring_form/field/submit'

data/lib/caring_form/form_builder.rb

@@ -0,0 +1,51 @@
+module CaringForm
+  class TextFieldInlineErrorField < SimpleForm::Inputs::CommonTextInput
+    def input
+      super.html_safe + '<div class="inline-error" style="display: none"></div>'.html_safe
+    end
+  end
+
+  class FormBuilder
+    def initialize(*args)
+      @form = args[1]
+      @builder = SimpleForm::FormBuilder.new(*args)
+      @builder.class.mappings[:string_inline_error] = TextFieldInlineErrorField
+    end
+
+    def metadata(options = {})
+      field(:all, options.merge(:filter_type => [:metadata, :dummy]))
+    end
+
+    def fields(options = {}, &block)
+      tag = options.delete(:tag) || :ol
+      @builder.template.content_tag(tag, options, &block)
+    end
+
+    def field(*names)
+      options = names.extract_options!
+      html_list = select_fields!(names, options).map do |field|
+        field.render(@form, @builder, options)
+      end
+      html_list.join("\n").html_safe
+    end
+
+    def method_missing(meth, *args, &blk)
+      return super unless @builder.respond_to?(meth)
+      @builder.send(meth, *args, &blk)
+    end
+
+    private
+
+    def select_fields!(names, options)
+      names = @form.field_names.map(&:to_sym) + [:submit] if names == [:all]
+      if options.has_key?(:except)
+        names -= Array(options.delete(:except))
+      end
+      types = Array(options.delete(:filter_type)) if options.has_key?(:filter_type)
+      @form.field_definitions.select do |field|
+        next false unless names.include?(field.name)
+        types.nil? ? true : types.include?(field.type)
+      end
+    end
+  end
+end

data/lib/caring_form/model.rb

@@ -0,0 +1,58 @@
+require 'caring_form/dsl'
+
+module CaringForm
+  class Model
+    INHERITED_ATTRIBUTES = [:url, :id, :classes]
+    attr_accessor *INHERITED_ATTRIBUTES
+
+    def self.inherited(klass)
+      klass.instance_eval do
+        include CaringForm::Dsl
+      end
+    end
+
+    # attributes can be scoped within key of the name of the class (posted form)
+    # or a flat hash of attributes
+    def initialize(attributes = {})
+      flatten_attributes(attributes).each do |name, value|
+        send("#{name}=", normalize_attribute_value(name, value)) if respond_to?(name)
+      end
+      (INHERITED_ATTRIBUTES - attributes.keys).each do |name|
+        value = self.class.send(name)
+        send("#{name}=", value) unless value.nil?
+      end
+      after_initialize
+    end
+
+    def after_initialize
+      # override if needed
+    end
+
+    def normalize_attribute_value(name, value)
+      value
+    end
+
+    private
+
+    def flatten_attributes(raw_attributes)
+      attributes = raw_attributes.symbolize_keys
+      scope_key = self.class.model_name.to_s.underscore.to_sym
+      # flatten scoped attributes if any
+      if attributes.has_key?(scope_key)
+        scoped = attributes.delete(scope_key)
+        if (index_on_name = self.class.index_on)
+          index = attributes[index_on_name]
+          scoped = scoped[index]
+        end
+        attributes.merge!(scoped.respond_to?(:merge) ? scoped : {})
+      end
+      attributes
+    end
+  end
+end
+
+if defined?(ActiveModel)
+  require 'caring_form/model/active_model'
+else
+  require 'caring_form/model/active_record'
+end

data/lib/caring_form/model/active_model.rb

@@ -0,0 +1,11 @@
+module CaringForm
+  class Model
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    extend ActiveModel::Naming
+
+    def persisted?
+      false
+    end
+  end
+end

data/lib/caring_form/model/active_record.rb

@@ -0,0 +1,38 @@
+module CaringForm
+  class Model
+    attr_accessor :errors
+
+    def self.human_name
+      to_s.humanize
+    end
+
+    def self.human_attribute_name(attribute)
+      attribute.to_s.humanize
+    end
+
+    def self.self_and_descendants_from_active_record
+      [self]
+    end
+
+    def save
+      # TODO
+    end
+
+    def save!
+      # TODO
+    end
+
+    def new_record?
+      true
+    end
+
+    def update_attribute
+    end
+
+    include ActiveRecord::Validations
+
+    def after_initialize
+      @errors = ActiveRecord::Errors.new(self)
+    end
+  end
+end

data/lib/caring_form/simple_form/initializer.rb

@@ -0,0 +1,26 @@
+# TODO: support only SimpleForm 2.x+ once we upgrade all our apps to Rails 3.2
+
+require 'simple_form'
+
+SimpleForm.setup do |config|
+
+  if config.respond_to?(:wrappers)
+    # SimpleForm 2+
+    config.wrappers :tag => :div do |b|
+      b.use :label
+      b.use :input
+      b.use :hint, :wrap_with => {:tag => :p, :class => 'hint'}
+    end
+  else
+    # SimpleForm 1
+    config.components  = [ :label, :input, :hint ]
+    config.wrapper_tag = :div
+    config.hint_tag    = :p
+  end
+
+  # Common
+  config.label_text = lambda { |label, required, explicit_label = nil|
+    "#{label}#{required.empty? ? ' <span class="opt">(optional)</span>' : ''}"
+  }
+
+end

data/lib/caring_form/simple_form/monkey_patching.rb

@@ -0,0 +1,51 @@
+require 'simple_form'
+
+module SimpleForm
+  module Inputs
+    CommonTextInput = if defined?(TextFieldInput)
+                        TextFieldInput
+                      elsif defined?(StringInput)
+                        StringInput
+                      end
+
+    Base.class_eval do
+      alias :orig_html_options_for :html_options_for
+      def html_options_for(*args)
+        orig_html_options_for(*args).tap do |options|
+          if options[:class] && options[:class].respond_to?(:split)
+            options[:class] = options[:class].split(' ').uniq.join(' ')
+          end
+        end
+      end
+    end
+
+    classes = [Base]
+    classes << CollectionRadioButtonsInput if defined?(CollectionRadioButtonsInput)
+    classes.each do |klass|
+      klass.class_eval do
+        alias :orig_input :input
+        def input(wrapper_options = nil)
+          options = input_html_options
+          wrapper = options.delete(:wrapper)
+          wrapper.nil? ? orig_input : template.content_tag(wrapper, orig_input)
+        end
+      end
+    end
+  end
+end
+
+# TODO: make something like below work instead...
+#
+# module CaringForm
+#   module CanWrapInputField
+#     def input
+#       options = input_html_options
+#       wrapper = options.delete(:wrapper)
+#       content = super
+#       wrapper.nil? ? content : template.content_tag(wrapper, content)
+#     end
+#   end
+# end
+
+# SimpleForm::Inputs::TextFieldInput.send(:include, CaringForm::CanWrapInputField)
+# SimpleForm::Inputs::CollectionInput.send(:include, CaringForm::CanWrapInputField)

data/lib/caring_form/tools/referee.rb

@@ -0,0 +1,62 @@
+module CaringForm
+  module Tools
+    # A referee is a tool used to execute rules stored in a field attribute
+    # against value(s) retrieved from a form instance. The referee decides
+    # if the rule is true or false for the form instance.
+    #
+    # i.e.:
+    #  field = OpenStruct.new(:optional => {:absent => :band_name})
+    #  form = OpenStruct.new(:band_name => "")
+    #  referee = Tools::Referee.new(field)
+    #
+    #  # We want to know if the field is optional 
+    #  referee.decide(:optional, form) # => true, because the band name is absent
+    #  form.band_name = "Everything But The Girl"
+    #  referee.decide(:optional, form) # => false, now that there is a band name, the field is not optional anymore
+    #
+    #  # We also need to verify that on the front-end, so the referee can translate
+    #  # the rule into a data attribute key value pair
+    #  def form.field_id(name); "form_name_index_#{name}"; end
+    #  referee.rule_as_data_attribute(:optional, form)  # => data-optional-if-absent="#form_name_index_band_name"
+    class Referee
+      def initialize(field)
+        @field = field
+      end
+
+      def decide(property, form)
+        case (value = @field.send(property))
+        when true then true
+        when false then false
+        else
+          execute_rule(value, form)
+        end
+      end
+
+      def execute_rule(rule, form)
+        type = rule.keys.first
+        attribute = rule[type]
+        case type
+        when :absent then  form.send(attribute).blank?
+        when :present then form.send(attribute).present?
+        else
+          false
+        end
+      end
+
+      def is_rule?(property)
+        @field.send(property).is_a?(Hash)
+      end
+
+      def rule_as_data_attribute(property, form)
+        rule = @field.send(property)
+        if rule.respond_to?(:keys) && (type = rule.keys.first)
+          name = :"data-#{property}-if-#{type}"
+          id   = "##{form.field_id(rule[type])}"
+          {name => id}
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/caring_form/version.rb

@@ -0,0 +1,3 @@
+module CaringForm
+  VERSION = "1.2.3" unless defined?(CaringForm::VERSION)
+end

data/lib/tasks/webshims.rake

@@ -0,0 +1,7 @@
+require 'fileutils'
+
+desc "Copy the webshims to public so dynamic features will work. Only needs to run when caring_form updates the webshims."
+task "webshims:update_public" do
+  shim_root = Webshims::Rails::Engine.root.join('vendor', 'assets', 'javascripts', 'webshims')
+  FileUtils.cp_r(shim_root, Rails.root.join("public/webshims"))
+end

data/spec/caring_form/action_view_extensions/flash_error_helper_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+require 'caring_form'
+
+class FlashForm < CaringForm::Model
+  url '/'
+  string :name, :required_message => "Enter your name"
+  string :age,  :required_message => "Enter your age as a number"
+
+  validates_numericality_of :age,
+    :greater_than_or_equal_to => 0,
+    :only_integer => true,
+    :allow_blank => true,
+    :message => "Age must be a number"
+
+  on_error :header  => "flash header",
+           :message => "flash message"
+end
+
+MiniTest::Spec.register_spec_type(/CaringForm::ActionViewExtensions::FlashErrorHelper$/, ControllerSpec)
+
+describe CaringForm::ActionViewExtensions::FlashErrorHelper do
+  it "renders a flash error if the form is not valid" do
+    view = caring_form_errors_for(FlashForm.new)
+    html_matcher('.flash.error > h2').must_be :matching, view
+    html_matcher('.flash.error > .flash-close').must_be :matching, view
+    html_matcher('.flash.error > .message').must_be :matching, view
+    html_matcher('.flash.error > .message > ul').must_be :matching, view
+  end
+
+  it "doesn't render a flash error if the form is valid" do
+    form = FlashForm.new(:name => "Zhanna", :age => "30")
+    caring_form_errors_for(form).must_equal ''
+  end
+
+  it "renders the header setup with #error_for" do
+    view = caring_form_errors_for(FlashForm.new)
+    html_matcher('.flash.error > h2', :text => "flash header").must_be :matching, view
+  end
+
+  it "renders a list of all the error messages" do
+    view = caring_form_errors_for(FlashForm.new)
+    html_matcher(
+      '.flash.error > .message li', :text => "Enter your name"
+    ).must_be :matching, view
+    html_matcher(
+      '.flash.error > .message li', :text => "Enter your age as a number"
+    ).must_be :matching, view
+  end
+end