formbuilder-rb 0.0.1

data/lib/formbuilder/entry.rb

@@ -0,0 +1,242 @@
+module Formbuilder
+  module Entry
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :old_responses
+      attr_accessor :skip_validation
+      validates_with Formbuilder::EntryValidator
+      before_save :calculate_responses_text, if: :responses_changed?
+      include ActionView::Helpers::TextHelper
+    end
+
+    def submit!(skip_validation = false)
+      return false if !skip_validation && !valid?
+
+      self.audit_responses
+
+      self.update_attributes(
+        submitted_at: Time.now,
+        skip_validation: true # don't validate twice
+      )
+    end
+
+    def unsubmit!
+      self.update_attributes(
+        submitted_at: nil,
+        skip_validation: true
+      )
+    end
+
+    def submitted?
+      self.submitted_at.present?
+    end
+
+    def value_present?(response_field)
+      value = self.response_value(response_field)
+
+      # value isn't blank (ignore hashes)
+      return true if (value && value.present? && !value.is_a?(Hash))
+
+      # no options are available
+      return true if (response_field.options_field && Array(response_field.field_options["options"]).empty?)
+
+      # there is at least one value (for hashes)
+      # reject select fields
+      return true if (value.is_a?(Hash) && value.reject { |k, v| k.in? ['am_pm', 'country'] }.find { |k, v| v.present? })
+
+      # otherwise, it's not present
+      return false
+    end
+
+    # checkboxes can have no values, yet still need to show up as unchecked
+    def value_present_or_checkboxes?(response_field)
+      response_field.field_type == 'checkboxes' || value_present?(response_field)
+    end
+
+    def response_value(response_field)
+      value = responses && responses[response_field.id.to_s]
+
+      if value
+        response_field.serialized ? YAML::load(value) : value
+      elsif !value && response_field.serialized && response_field.field_type != 'checkboxes'
+        {}
+      else # for checkboxes, we need to know the difference between no value and none selected
+        nil
+      end
+    end
+
+    def save_responses(response_field_params, response_fields)
+      self.old_responses = self.responses.try(:clone) || {}
+      self.responses = {}
+
+      response_fields.reject { |rf| !rf.input_field }.each do |response_field|
+        self.save_response(response_field_params.try(:[], response_field.id.to_s), response_field, response_field_params)
+      end
+    end
+
+    def save_response(raw_value, response_field, response_field_params = {})
+      value = case response_field.field_type
+      when "checkboxes"
+        # transform checkboxes into {label => on/off} pairs
+        values = {}
+
+        (response_field[:field_options]["options"] || []).each_with_index do |option, index|
+          label = response_field.field_options["options"][index]["label"]
+          values[option["label"]] = raw_value && raw_value[index.to_s] == "on"
+        end
+
+        if raw_value && raw_value['other_checkbox'] == 'on'
+          values['Other'] = raw_value['other']
+        else
+          values.delete('Other') # @todo this might cause unexpected behavior to the user. we should hide/show the other field in the frontend, too
+        end
+
+        # Save 'other' value
+        responses["#{response_field.id}_other"] = raw_value && raw_value['other_checkbox'] == 'on' ?
+                                                    true :
+                                                    nil
+
+        values
+
+      when "file"
+        # if the file is already uploaded and we're not uploading another,
+        # be sure to keep it
+        if raw_value.blank?
+          if old_responses && old_responses[response_field.id.to_s]
+            old_responses[response_field.id.to_s]
+          end
+        else
+          remove_entry_attachment(responses[response_field.id.to_s]) if responses
+          attachment = EntryAttachment.create(upload: raw_value)
+          attachment.id
+        end
+      when "radio"
+        # Save 'other' value
+        responses["#{response_field.id}_other"] = raw_value == 'Other' ?
+                                                    response_field_params["#{response_field.id}_other"] :
+                                                    nil
+
+        raw_value
+      else
+        raw_value
+      end
+
+      self.responses ||= {}
+
+      if value.present?
+        self.responses["#{response_field.id}"] = response_field.serialized ? value.to_yaml : value
+        calculate_sortable_value(response_field, value)
+      end
+
+      self.responses_will_change! # hack to make sure column is marked as dirty
+    end
+
+    def destroy_response(response_field)
+      case response_field.field_type
+      when "file"
+        self.remove_entry_attachment(responses[response_field.id.to_s])
+      end
+
+      id = response_field.id.to_s
+      new_responses = self.responses.reject { |k, v| k.in?([id, "#{id}_sortable_value"]) }
+      self.responses = new_responses
+
+      self.responses_will_change! # hack to make sure column is marked as dirty
+    end
+
+    def remove_entry_attachment(entry_attachment_id)
+      return unless entry_attachment_id.present?
+      EntryAttachment.where(id: entry_attachment_id).first.try(:destroy)
+    end
+
+    def error_for(response_field)
+      (self.errors.messages[:"responses_#{response_field.id}"] || [])[0]
+    end
+
+    def calculate_responses_text
+      return unless self.respond_to?(:"responses_text=")
+      selected_responses = self.responses.select { |k, v| Integer(k) rescue nil }
+      self.responses_text = selected_responses.values.join(' ')
+    end
+
+    # useful when migrating
+    def calculate_sortable_values
+      response_fieldable.response_fields.reject { |rf| !rf.input_field }.each do |response_field|
+        calculate_sortable_value(response_field, response_value(response_field))
+      end
+
+      self.responses_will_change! # hack to make sure column is marked as dirty
+    end
+
+    def calculate_additional_info
+      response_fieldable.response_fields.reject { |rf| !rf.input_field }.each do |response_field|
+        value = response_value(response_field)
+        next unless value.present?
+
+        case response_field.field_type
+        when 'address'
+          begin
+            coords = Geocoder.coordinates("#{value['street']} #{value['city']} #{value['state']} #{value['zipcode']} #{value['country']}")
+            self.responses["#{response_field.id}_x"] = coords[0]
+            self.responses["#{response_field.id}_y"] = coords[1]
+          rescue
+            self.responses["#{response_field.id}_x"] = nil
+            self.responses["#{response_field.id}_y"] = nil
+          end
+        end
+      end
+    end
+
+    # def normalize_responses
+    #   response_fieldable.response_fields.reject { |rf| !rf.input_field }.each do |response_field|
+    #     value = response_value(response_field)
+    #     next unless value.present?
+
+    #     case response_field.field_type
+    #     when 'website'
+    #       unless value[/^http:\/\//] || value[/^https:\/\//]
+    #         save_response("http://#{value}", response_field)
+    #       end
+    #     end
+    #   end
+    # end
+
+    def audit_responses
+      form.response_fields.each do |response_field|
+        response_field.audit_response(self.response_value(response_field), self.responses)
+      end
+    end
+
+    def calculate_sortable_value(response_field, value)
+      return unless value.present?
+
+      self.responses["#{response_field.id}_sortable_value"] = case response_field.field_type
+      when "date"
+        ['year', 'month', 'day'].each { |x| return 0 unless value[x] && !value[x].blank? }
+        DateTime.new(value['year'].to_i, value['month'].to_i, value['day'].to_i).to_i rescue 0
+      when "time"
+        hours = value['hours'].to_i
+        hours += 12 if value['am_pm'] && value['am_pm'] == 'PM'
+        (hours*60*60) + (value['minutes'].to_i * 60) + value['seconds'].to_i
+      when "file"
+        value ? 1 : 0
+      when "checkboxes"
+        calculate_sortable_value_for_checkboxes(response_field, value)
+        return nil
+      when "price"
+        "#{value['dollars'] || '0'}.#{value['cents'] || '0'}".to_f
+      else
+        # do we really need to sort more than the first 10 characters of a string?
+        value[0..10]
+      end
+    end
+
+    def calculate_sortable_value_for_checkboxes(response_field, value)
+      (response_field.field_options['options'] || []).each do |option|
+        self.responses["#{response_field.id}_sortable_values_#{option['label']}"] = value[option['label']]
+      end
+    end
+
+  end
+end

data/lib/formbuilder/entry_renderer.rb

@@ -0,0 +1,47 @@
+module Formbuilder
+  class EntryRenderer
+    include ActionView::Context
+    include ActionView::Helpers::TagHelper
+
+    def initialize(entry, form, opts = {})
+      @entry, @form = entry, form
+      @options = opts # merge defaults?
+    end
+
+    def fields
+      return_fields = @form.response_fields.reject { |rf| !rf.input_field }
+      return_fields.reject! { |rf| rf.blind? } unless @options[:show_blind]
+      return_fields
+    end
+
+    def to_html
+      content_tag 'dl', class: 'entry-dl' do
+        fields.map do |rf|
+          """
+            <dt>#{field_labels(rf)}</dt>
+            <dd>
+              #{field_value(rf) || no_value}
+            </dd>
+          """
+        end.join('').html_safe
+      end
+    end
+
+    def field_labels(rf)
+      """
+        #{rf.label}
+        #{rf.blind? ? '<span class="label">Blind</span>' : ''}
+        #{rf.admin_only? ? '<span class="label">Admin Only</span>' : ''}
+      """
+    end
+
+    def no_value
+      "<span class='no-response'>No response</span>"
+    end
+
+    def field_value(rf)
+      value = @entry.response_value(rf)
+      rf.render_entry(value, entry: @entry)
+    end
+  end
+end

data/lib/formbuilder/entry_table_renderer.rb

@@ -0,0 +1,58 @@
+module Formbuilder
+  class EntryTableRenderer < EntryRenderer
+    # include ActionView::Context
+    # include ActionView::Helpers::TagHelper
+
+    # def initialize(entry, form, opts = {})
+    #   @entry, @form = entry, form
+    #   @options = opts # merge defaults?
+    # end
+
+    # def fields
+    #   return_fields = @form.response_fields.reject { |rf| rf.non_input_field? }
+    #   return_fields.reject! { |rf| rf.blind? } unless @options[:show_blind]
+    #   return_fields
+    # end
+
+    def to_html
+      content_tag 'dl', class: 'entry-dl' do
+        fields.map do |rf|
+          field_value(rf)
+        end.join('').html_safe
+      end
+    end
+
+    def field_value(rf)
+      value = @entry.response_value(rf)
+      rf.field_class.render_entry_for_table(rf, value, entry: @entry)
+    end
+
+    # def field_labels(rf)
+    #   """
+    #     #{rf.label}
+    #     #{rf.blind? ? '<span class="label">Blind</span>' : ''}
+    #     #{rf.admin_only? ? '<span class="label">Admin Only</span>' : ''}
+    #   """
+    # end
+
+    # def no_value
+    #   "<span class='no-response'>No response</span>"
+    # end
+
+    # def field_value(rf)
+    #   value = @entry.response_value(rf)
+    #   Formbuilder::Fields.const_get(rf.field_type.camelize + 'Field').render_entry(rf, value, entry: @entry)
+    # end
+
+    # def checkboxes_for_table
+    #   (@response_field.field_options['options'] || []).map do |option|
+    #     """
+    #       <td data-column-id='#{@response_field.id}_sortable_values_#{option['label']}'>
+    #         <i class='#{@value && @value[option['label']] ? 'icon-ok' : 'icon-remove'}'></i>
+    #       </td>
+    #     """
+    #   end.join('')
+    # end
+
+  end
+end

data/lib/formbuilder/entry_validator.rb

@@ -0,0 +1,107 @@
+module Formbuilder
+  class EntryValidator < ActiveModel::Validator
+    SHARED_VALIDATION_METHODS = [:min_max_length, :min_max, :integer_only]
+
+    def validate(record)
+      @record = record
+
+      # I guess it's valid if there's no form?
+      return unless record.form
+
+      # It's also valid if it has already been submitted
+      return if record.submitted_at_was
+
+      # we can also skip validation by setting this flag
+      return if record.skip_validation
+
+      record.form.response_fields.not_admin_only.reject { |rf| !rf.input_field }.each do |response_field|
+        @response_field = response_field
+        @value = @record.response_value(@response_field)
+
+        if @response_field.required? && !@record.value_present?(@response_field)
+          add_error "can't be blank"
+          next
+        end
+
+        if @record.value_present?(@response_field)
+          # Field-specific validation
+          add_error(@response_field.validate_response(@value))
+
+          SHARED_VALIDATION_METHODS.each do |method_name|
+            run_validation(method_name)
+          end
+        end
+      end
+    end
+
+    private
+    def add_error(msg)
+      return unless msg.present?
+      @record.errors["responses_#{@response_field.id}"] << msg
+    end
+
+    def run_validation(method_name)
+      if (error_message = send(method_name))
+        add_error(error_message)
+      end
+    end
+
+    def min_max_length
+      return unless @response_field.field_options["minlength"].present? ||
+                    @response_field.field_options["maxlength"].present?
+
+      if @response_field.field_options["min_max_length_units"] == 'words'
+        min_max_length_words
+      else
+        min_max_length_characters
+      end
+    end
+
+    def min_max_length_characters
+      if @response_field.field_options["minlength"].present? && (@value.length < @response_field.field_options["minlength"].to_i)
+        return "is too short. It should be #{@response_field.field_options["minlength"]} characters or more."
+      end
+
+      if @response_field.field_options["maxlength"].present? && (@value.length > @response_field.field_options["maxlength"].to_i)
+        return "is too long. It should be #{@response_field.field_options["maxlength"]} characters or less."
+      end
+    end
+
+    def min_max_length_words
+      if @response_field.field_options["minlength"].present? && (@value.scan(/\w+/).count < @response_field.field_options["minlength"].to_i)
+        return "is too short. It should be #{@response_field.field_options["minlength"]} words or more."
+      end
+
+      if @response_field.field_options["maxlength"].present? && (@value.scan(/\w+/).count > @response_field.field_options["maxlength"].to_i)
+        return "is too long. It should be #{@response_field.field_options["maxlength"]} words or less."
+      end
+    end
+
+    def min_max
+      return unless @response_field.field_options["min"].present? ||
+                    @response_field.field_options["max"].present?
+
+      value_for_comparison = case @response_field.field_type
+      when 'price'
+       "#{@value['dollars'] || 0}.#{@value['cents'] || 0}".to_f
+      else
+        @value.to_f
+      end
+
+      if @response_field.field_options["min"].present? && (value_for_comparison < @response_field.field_options["min"].to_f)
+        return "is too small. It should be #{@response_field.field_options["min"]} or more."
+      end
+
+      if @response_field.field_options["max"].present? && (value_for_comparison > @response_field.field_options["max"].to_f)
+        return "is too large. It should be #{@response_field.field_options["max"]} or less."
+      end
+    end
+
+    def integer_only
+      if @response_field.field_options["integer_only"] && !(Integer(@value) rescue false)
+        "only integers allowed."
+      end
+    end
+
+  end
+end

data/lib/formbuilder/form_renderer.rb

@@ -0,0 +1,102 @@
+module Formbuilder
+  class FormRenderer
+
+    include ActionView::Helpers::UrlHelper
+    include ActionView::Helpers::FormTagHelper
+    include ActionView::Context
+
+    def protect_against_forgery?; false; end;
+
+    DEFAULT_OPTIONS = {
+      action: '',
+      method: 'POST'
+    }
+
+    def initialize(form, entry, options = {})
+      @form, @entry = form, entry
+      @options = self.class::DEFAULT_OPTIONS.merge(options)
+    end
+
+    def to_html
+      form_tag @options[:action], method: @options[:method], class: 'formbuilder-form', multipart: true do
+        hidden_fields +
+        render_fields +
+        render_actions
+      end
+    end
+
+    def hidden_fields
+      """
+        <input type='hidden' name='draft_only' />
+      """.html_safe
+    end
+
+    def render_fields
+      @form.response_fields.map do |field|
+        @field = field
+        render_field
+      end.join('').html_safe
+    end
+
+    def render_field
+      value = @entry.try(:response_value, @field)
+
+      """
+        <div class='response-field-wrapper response-field-#{@field.field_type} #{@entry.try(:error_for, @field) && 'error'}'>
+          #{render_label}
+          #{@field.render_input(value, entry: @entry)}
+          <div class='cf'></div>
+          #{render_error}
+          #{render_description}
+          #{render_length_validations}
+          #{render_min_max_validations}
+        </div>
+      """
+    end
+
+    def render_label
+      return unless @field.input_field
+
+      """
+        <label>
+          #{@field[:label]}
+          #{render_label_required if @field.required?}
+        </label>
+      """
+    end
+
+    def render_label_required
+      "<abbr title='required'>*</abbr>"
+    end
+
+    def render_error
+      return unless @field.input_field
+      return unless @entry.error_for(@field)
+      "<span class='help-block validation-message-wrapper'>#{@entry.error_for(@field)}</span>"
+    end
+
+    def render_description
+      return unless @field.input_field
+      return if @field[:field_options]["description"].blank?
+      "<span class='help-block'>#{simple_format(@field[:field_options]["description"])}</span>"
+    end
+
+    def render_length_validations
+      return unless @field.input_field
+      return unless !@field.has_length_validations?
+    end
+
+    def render_min_max_validations
+      return unless @field.input_field
+    end
+
+    def render_actions
+      """
+        <div class='form-actions'>
+          <button class='button'>Submit</button>
+          <a class='button save-draft-button' data-loading-text='All changes saved'>Save draft</a>
+        </div>
+      """.html_safe
+    end
+  end
+end

data/lib/formbuilder/version.rb

@@ -0,0 +1,3 @@
+module Formbuilder
+  VERSION = "0.0.1"
+end

data/lib/formbuilder.rb

@@ -0,0 +1,12 @@
+require "formbuilder/engine"
+require "formbuilder/entry"
+require "formbuilder/entry_renderer"
+require "formbuilder/entry_table_renderer"
+require "formbuilder/entry_validator"
+require "formbuilder/form_renderer"
+
+module Formbuilder
+  def self.root
+    File.expand_path('../..', __FILE__)
+  end
+end

data/lib/tasks/formbuilder_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :formbuilder do
+#   # Task goes here
+# end