formbuilder-rb 0.0.4 → 0.2.0

data/bin/rails

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 4 gems installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+ENGINE_PATH = File.expand_path('../../lib/formbuilder/engine', __FILE__)
+
+require 'rails/all'
+require 'rails/engine/commands'

data/circle.yml

@@ -0,0 +1,9 @@
+machine:
+  environment:
+    COVERALLS_REPO_TOKEN: ppRfiNa1YEa2M9VtGpXw0AOzVqYEUEkFR
+
+database:
+  override:
+    - cp spec/dummy/config/database.yml.ci spec/dummy/config/database.yml
+    - bundle exec rake db:create db:schema:load
+

data/config/spring.rb

@@ -0,0 +1 @@
+Spring.application_root = './spec/dummy'

data/db/migrate/20130924185815_create_formbuilder_entry_attachments.rb

@@ -3,6 +3,7 @@ class CreateFormbuilderEntryAttachments < ActiveRecord::Migration
     create_table :formbuilder_entry_attachments do |t|
       t.string :upload
       t.string :content_type
+      t.integer :file_size
 
       t.timestamps
     end

data/formbuilder-rb.gemspec

@@ -0,0 +1,41 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "formbuilder/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "formbuilder-rb"
+  s.version     = Formbuilder::VERSION
+  s.authors     = ["Adam Becker"]
+  s.email       = ["adam@dobt.co"]
+  s.homepage    = "https://github.com/dobtco/formbuilder-rb"
+  s.summary     = "Build and save custom forms."
+  s.description = "This is a Rails Engine for https://github.com/dobtco/formbuilder."
+  s.license     = "MIT"
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {features,spec}/*`.split("\n")
+
+  s.add_dependency "rails", "4.1.0.rc1"
+
+  s.add_dependency 'carrierwave'
+  s.add_dependency 'erector-rails4'
+  s.add_dependency 'geocoder'
+  s.add_dependency 'pg'
+  s.add_dependency 'rinku'
+  s.add_dependency 'rmagick'
+
+  s.add_development_dependency 'capybara'
+  s.add_development_dependency 'database_cleaner'
+  s.add_development_dependency 'factory_girl_rails'
+  s.add_development_dependency 'guard-rspec'
+  s.add_development_dependency 'launchy'
+  s.add_development_dependency 'rspec-rails'
+  s.add_development_dependency 'spring'
+  s.add_development_dependency 'spring-commands-rspec'
+  s.add_development_dependency 'terminal-notifier-guard'
+  s.add_development_dependency 'thin'
+  s.add_development_dependency 'coveralls'
+
+end

data/formbuilder-rb.sublime-project

@@ -0,0 +1,20 @@
+{
+  "folders":
+  [
+    {
+      "path": ".",
+      "folder_exclude_patterns": ["coverage", "log", "tmp"],
+      "file_exclude_patterns": ["*.sublime-workspace", "*.sql"]
+    }
+  ],
+
+  "settings":
+  {
+    // indentation
+    "tab_size": 2,
+    "translate_tabs_to_spaces": true,
+    "trim_trailing_white_space_on_save": true,
+    // ensure line endings is linux style (even when on Windows)
+    "default_line_ending": "LF"
+  }
+}

data/lib/formbuilder.rb

@@ -1,9 +1,14 @@
+# Require dependencies explicitly
+require 'carrierwave'
+require 'erector'
+require 'geocoder'
+
 require "formbuilder/engine"
 require "formbuilder/entry"
-require "formbuilder/entry_renderer"
-require "formbuilder/entry_table_renderer"
 require "formbuilder/entry_validator"
-require "formbuilder/form_renderer"
+require "formbuilder/views/form"
+require "formbuilder/views/form_field"
+require "formbuilder/views/entry_dl"
 
 module Formbuilder
   def self.root

data/lib/formbuilder/entry.rb

@@ -3,33 +3,82 @@ module Formbuilder
     extend ActiveSupport::Concern
 
     included do
-      attr_accessor :old_responses
-      attr_accessor :skip_validation
+      attr_accessor :skip_validation, :only_validate_page
+
+      before_validation :normalize_responses
       validates_with Formbuilder::EntryValidator
-      before_save :calculate_responses_text, if: :responses_changed?
-      include ActionView::Helpers::TextHelper
+      before_save :calculate_responses_text, if: :responses_column_changed?
+
+      scope :order_by_response_field_value, -> (response_field, direction) {
+        if response_field.sort_as_numeric
+          order("(responses -> '#{response_field.id}_sortable_value') ::numeric #{direction} NULLS LAST")
+        else
+          order("LOWER(responses -> '#{response_field.id}_sortable_value') #{direction} NULLS LAST")
+        end
+      }
+
+      scope :order_by_response_field_checkbox_value, -> (response_field, option, direction) {
+        order("(CASE WHEN (responses -> '#{response_field.id}_sortable_values_#{option}') = 'true' THEN
+                  1
+                ELSE
+                  0
+                END) #{direction}".squish)
+      }
+
+      scope :order_by_response_field_table_sum, -> (response_field, column, direction) {
+        order("(responses -> '#{response_field.id}_sum_#{column}') ::numeric #{direction}")
+      }
+    end
+
+    def valid_page?(x)
+      self.valid?
+      !self.errors_on_page?(x)
+    end
+
+    def first_page_with_errors
+      if (i = pages_with_errors.find_index { |x| x == true })
+        i + 1
+      else
+        nil
+      end
+    end
+
+    def pages_with_errors
+      form.response_fields_by_page.map do |page|
+        page.find { |response_field| self.error_for(response_field).present? } ? true : false
+      end
+    end
+
+    def errors_on_page?(x)
+      pages_with_errors[x - 1] # 0-indexed
+    end
+
+    def responses_column
+      @responses_column || 'responses'
+    end
+
+    def responses_column=(x)
+      @responses_column = x
     end
 
-    def submit!(skip_validation = false)
-      return false if !skip_validation && !valid?
+    def get_responses
+      send(responses_column)
+    end
 
-      self.audit_responses
+    def set_responses(x)
+      send("#{responses_column}=", x)
+    end
 
-      self.update_attributes(
-        submitted_at: Time.now,
-        skip_validation: true # don't validate twice
-      )
+    def mark_responses_as_changed!
+      send("#{responses_column}_will_change!")
     end
 
-    def unsubmit!
-      self.update_attributes(
-        submitted_at: nil,
-        skip_validation: true
-      )
+    def responses_column_changed?
+      send("#{responses_column}_changed?")
     end
 
-    def submitted?
-      self.submitted_at.present?
+    def responses_column_was
+      send("#{responses_column}_was")
     end
 
     def value_present?(response_field)
@@ -49,13 +98,8 @@ module Formbuilder
       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]
+      value = get_responses[response_field.id.to_s]
 
       if value
         response_field.serialized ? YAML::load(value) : value
@@ -66,176 +110,75 @@ module Formbuilder
       end
     end
 
-    def save_responses(response_field_params, response_fields)
-      self.old_responses = self.responses.try(:clone) || {}
-      self.responses = {}
+    def save_responses(response_field_params, response_fields, opts = {})
+      set_responses({}) unless opts[:partial_update]
 
-      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)
+      response_fields.select { |rf| rf.input_field }.each do |response_field|
+        self.save_response(response_field_params[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 ||= {}
+      value = response_field.transform_raw_value(raw_value, self, response_field_params: response_field_params)
 
       if value.present?
-        self.responses["#{response_field.id}"] = response_field.serialized ? value.to_yaml : value
-        calculate_sortable_value(response_field, value)
+        get_responses["#{response_field.id}"] = response_field.serialized ? value.to_yaml : value
+        get_responses["#{response_field.id}_sortable_value"] = response_field.sortable_value(value)
+      else
+        get_responses.delete("#{response_field.id}")
+        get_responses.delete("#{response_field.id}_sortable_value")
       end
 
-      self.responses_will_change! # hack to make sure column is marked as dirty
+      mark_responses_as_changed!
     end
 
     def destroy_response(response_field)
-      case response_field.field_type
-      when "file"
-        self.remove_entry_attachment(responses[response_field.id.to_s])
-      end
-
+      response_field.before_response_destroyed(self)
       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)
+      set_responses get_responses.reject { |k, v| k.in?([id, "#{id}_sortable_value"]) }
+      mark_responses_as_changed!
     end
 
     def error_for(response_field)
-      (self.errors.messages[:"responses_#{response_field.id}"] || [])[0]
+      Array(self.errors.messages[:"#{responses_column}_#{response_field.id}"]).first
     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(' ')
+      return unless self.respond_to?(:"#{responses_column}_text=")
+      self.send(:"#{responses_column}_text=", get_responses.select { |k, v| Integer(k) rescue nil }.values.join(' '))
     end
 
-    # useful when migrating
+    # for manual use, maybe 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))
+      response_fieldable.input_fields.each do |response_field|
+        if (x = response_value(response_field)).present?
+          get_responses["#{response_field.id}_sortable_value"] = response_field.sortable_value(x)
+        end
       end
 
-      self.responses_will_change! # hack to make sure column is marked as dirty
+      mark_responses_as_changed!
     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?
+    # Normalizations get run before validation.
+    def normalize_responses
+      return if form.blank?
 
-        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
+      form.response_fields.each do |response_field|
+        if (x = self.response_value(response_field))
+          response_field.normalize_response(x, get_responses)
         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
+      mark_responses_as_changed!
+    end
 
+    # Audits get run explicitly.
     def audit_responses
       form.response_fields.each do |response_field|
-        response_field.audit_response(self.response_value(response_field), self.responses)
+        response_field.audit_response(self.response_value(response_field), get_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
+      mark_responses_as_changed!
     end
 
   end

data/lib/formbuilder/entry_validator.rb

@@ -6,15 +6,22 @@ module Formbuilder
       @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
+      return if record.form.blank?
 
       # 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|
+      record.form.show_blind = true
+
+      if record.only_validate_page
+        query = record.form.response_fields_for_page(record.only_validate_page)
+      else
+        query = record.form.filtered_response_fields
+      end
+
+      query = query.reject { |rf| !rf.input_field }
+
+      query.each do |response_field|
         @response_field = response_field
         @value = @record.response_value(@response_field)
 
@@ -37,7 +44,7 @@ module Formbuilder
     private
     def add_error(msg)
       return unless msg.present?
-      @record.errors["responses_#{@response_field.id}"] << msg
+      @record.errors["#{@record.responses_column}_#{@response_field.id}"] << msg
     end
 
     def run_validation(method_name)