formblocks 0.1.0

data/app/models/formblocks/block.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Formblocks
+  # A block on a page: a piece of content (heading, paragraph, image) or an
+  # input the visitor answers. Single-table inheritance; every block is a Ruby
+  # class under Formblocks::Blocks, and hosts can subclass and register their own:
+  #
+  #   class Rating < Formblocks::Blocks::Input; end
+  #   Formblocks::Block.register 'Rating'
+  class Block < ApplicationRecord
+    include Attachable
+
+    KEY_FORMAT = /\A[a-z0-9_]+\z/
+
+    belongs_to :page, inverse_of: :blocks, touch: true
+    attachable :image
+
+    # The palette, in the order the builder shows it. Class names as strings
+    # so they autoload on first use.
+    class_attribute :registered_types, instance_writer: false, default: %w[
+      Formblocks::Blocks::Heading
+      Formblocks::Blocks::Paragraph
+      Formblocks::Blocks::Image
+      Formblocks::Blocks::Name
+      Formblocks::Blocks::Email
+      Formblocks::Blocks::Phone
+      Formblocks::Blocks::Url
+      Formblocks::Blocks::Text
+      Formblocks::Blocks::Textarea
+      Formblocks::Blocks::Hidden
+      Formblocks::Blocks::Checkbox
+      Formblocks::Blocks::RadioGroup
+    ]
+
+    normalizes :key, with: ->(key) { key.to_s.parameterize(separator: '_').presence }
+
+    before_validation :assign_key, if: :input?
+    before_create :assign_position
+
+    validates :type, inclusion: { in: ->(_block) { Block.registered_types } }
+    validates :label, presence: true, if: :label_required?
+    validates :label, :placeholder, length: { maximum: 200 }
+    validates :help_text, length: { maximum: 500 }
+    validates :content, length: { maximum: 10_000 }
+    validates :key, presence: true, length: { maximum: 60 }, format: { with: KEY_FORMAT }, if: :input?
+    validate :key_unique_within_form, if: :input?
+
+    class << self
+      # "radio_group" for Formblocks::Blocks::RadioGroup — the identifier used
+      # in templates, the palette and partial names.
+      def kind
+        name.demodulize.underscore
+      end
+
+      def registry
+        registered_types.map(&:constantize)
+      end
+
+      def kinds
+        registry.map(&:kind)
+      end
+
+      def content_registry
+        registry.reject(&:input?)
+      end
+
+      def input_registry
+        registry.select(&:input?)
+      end
+
+      def find_kind(kind)
+        registry.find { |klass| klass.kind == kind.to_s } ||
+          raise(ArgumentError, "Unknown block kind: #{kind.inspect}")
+      end
+
+      def register(class_name)
+        Block.registered_types += [class_name.to_s] unless Block.registered_types.include?(class_name.to_s)
+      end
+
+      def display_name
+        I18n.t("formblocks.blocks.#{kind}.name", default: kind.humanize)
+      end
+
+      # Capabilities — what the builder shows and the public page renders.
+      def input? = false
+      def content? = false
+      def options? = false
+      def placeholder? = false
+      def requirable? = false
+      def image? = false
+
+      # Attributes for a block freshly added from the palette.
+      def default_attributes
+        {}
+      end
+
+      # `base`, or `base_2`, `base_3`… until it is not in `taken`.
+      def unique_key(base, taken)
+        candidate = base
+        n = 2
+        while taken.include?(candidate)
+          candidate = "#{base}_#{n}"
+          n += 1
+        end
+        candidate
+      end
+    end
+
+    delegate :kind, :input?, :content?, :options?, :placeholder?, :requirable?, :image?, :display_name,
+             to: :class
+
+    # Rendered in the visible flow of the public form (hidden fields are not).
+    def visible?
+      true
+    end
+
+    # The partial the public page renders this block with. Subclasses that
+    # look alike share one (every single-line text input uses `text`).
+    def public_partial
+      "formblocks/public/blocks/#{kind}"
+    end
+
+    # Swap with the neighbouring block on the same page.
+    def move(direction)
+      list = page.blocks.reload.to_a
+      index = list.index { |block| block.id == id }
+      other = direction.to_s == 'up' ? index - 1 : index + 1
+      return if index.nil? || other.negative? || other >= list.size
+
+      list[index], list[other] = list[other], list[index]
+      transaction do
+        list.each_with_index { |block, i| block.update_column(:position, i + 1) }
+      end
+      page.blocks.reset
+    end
+
+    def label_required?
+      false
+    end
+
+    # Options as the builder edits them: one per line.
+    def options_text
+      Array(options).join("\n")
+    end
+
+    def options_text=(text)
+      self.options = text.to_s.lines.map(&:strip).compact_blank
+    end
+
+    # The key an input gets when none was given: from the label ("Work email"
+    # → "work_email"), else the kind.
+    def default_key
+      (label.presence || kind).to_s.parameterize(separator: '_').presence || kind
+    end
+
+    private
+
+    def assign_key
+      self.key = self.class.unique_key(default_key, sibling_keys) if key.blank?
+    end
+
+    def sibling_keys
+      form = page&.form
+      return [] unless form&.persisted?
+
+      form.blocks.where.not(id: id).where.not(key: nil).pluck(:key)
+    end
+
+    def key_unique_within_form
+      errors.add(:key, :taken) if key.present? && sibling_keys.include?(key)
+    end
+
+    def assign_position
+      self.position = (page.blocks.maximum(:position) || 0) + 1 if position.to_i.zero? && page&.persisted?
+    end
+  end
+end

data/app/models/formblocks/blocks/checkbox.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Formblocks
+  module Blocks
+    # A single yes/no checkbox. Required means it must be ticked.
+    class Checkbox < Input
+      def self.placeholder? = false
+
+      def normalize_answer(value)
+        ActiveModel::Type::Boolean.new.cast(value) ? true : false
+      end
+
+      def validate_answer(value, errors)
+        errors.add(key.to_sym, I18n.t('formblocks.errors.must_be_checked')) if required? && !value
+      end
+
+      def display_answer(value)
+        I18n.t(value ? 'formblocks.blocks.defaults.yes' : 'formblocks.blocks.defaults.no')
+      end
+    end
+  end
+end

data/app/models/formblocks/blocks/email.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Formblocks
+  module Blocks
+    class Email < Text
+      FORMAT = /\A[^@\s]+@[^@\s]+\.[^@\s]+\z/
+
+      def self.autocomplete = 'email'
+
+      def html_input_type
+        'email'
+      end
+
+      def normalize_answer(value)
+        super.downcase
+      end
+
+      def validate_present_answer(value, errors)
+        errors.add(key.to_sym, I18n.t('formblocks.errors.invalid_email')) unless value.to_s.match?(FORMAT)
+      end
+    end
+  end
+end

data/app/models/formblocks/blocks/heading.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Formblocks
+  module Blocks
+    class Heading < Block
+      def self.content? = true
+
+      def self.default_attributes
+        { content: I18n.t('formblocks.blocks.defaults.heading') }
+      end
+    end
+  end
+end

data/app/models/formblocks/blocks/hidden.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Formblocks
+  module Blocks
+    # A field the visitor never sees. `key` is its name, `content` its default
+    # value; a query parameter with the same name on the public URL overrides
+    # the default, so ?utm_source=newsletter lands in the response.
+    class Hidden < Input
+      def self.placeholder? = false
+      def self.requirable? = false
+
+      def visible?
+        false
+      end
+
+      def label_required?
+        false
+      end
+
+      def default_value
+        content.to_s
+      end
+    end
+  end
+end

data/app/models/formblocks/blocks/image.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Formblocks
+  module Blocks
+    # An uploaded image. `label` doubles as the alt text.
+    class Image < Block
+      def self.image? = true
+
+      def image_attached?
+        Formblocks.attachments? && image.attached?
+      end
+    end
+  end
+end

data/app/models/formblocks/blocks/input.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Formblocks
+  module Blocks
+    # Base of every block a visitor answers. Subclasses set the HTML input
+    # type, autocomplete hint and validation; the answer is stored in the
+    # response's `answers` hash under the block's `key`.
+    class Input < Block
+      MAX_ANSWER_LENGTH = 10_000
+
+      def self.input? = true
+      def self.placeholder? = true
+      def self.requirable? = true
+
+      def self.default_attributes
+        { label: display_name }
+      end
+
+      # The HTML autocomplete token, or nil.
+      def self.autocomplete
+        nil
+      end
+
+      def html_input_type
+        'text'
+      end
+
+      delegate :autocomplete, to: :class
+
+      def label_required?
+        true
+      end
+
+      # The submitted value as it is stored.
+      def normalize_answer(value)
+        value.to_s.strip
+      end
+
+      # Adds errors to `errors` under this block's key.
+      def validate_answer(value, errors)
+        if value.blank?
+          errors.add(key.to_sym, I18n.t('formblocks.errors.required')) if required?
+        elsif value.to_s.length > MAX_ANSWER_LENGTH
+          errors.add(key.to_sym, I18n.t('formblocks.errors.too_long'))
+        else
+          validate_present_answer(value, errors)
+        end
+      end
+
+      # Type-specific checks on a non-blank answer.
+      def validate_present_answer(_value, _errors); end
+
+      # The answer as the dashboard and CSV show it.
+      def display_answer(value)
+        value.to_s
+      end
+    end
+  end
+end

data/app/models/formblocks/blocks/name.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Formblocks
+  module Blocks
+    class Name < Text
+      def self.autocomplete = 'name'
+    end
+  end
+end

data/app/models/formblocks/blocks/paragraph.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Formblocks
+  module Blocks
+    class Paragraph < Block
+      def self.content? = true
+
+      def self.default_attributes
+        { content: I18n.t('formblocks.blocks.defaults.paragraph') }
+      end
+    end
+  end
+end

data/app/models/formblocks/blocks/phone.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Formblocks
+  module Blocks
+    class Phone < Text
+      def self.autocomplete = 'tel'
+
+      def html_input_type
+        'tel'
+      end
+    end
+  end
+end

data/app/models/formblocks/blocks/radio_group.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Formblocks
+  module Blocks
+    # Pick one of several options.
+    class RadioGroup < Input
+      def self.options? = true
+      def self.placeholder? = false
+
+      def self.default_attributes
+        { label: display_name,
+          options: (1..3).map { |n| I18n.t('formblocks.blocks.defaults.option', n:) } }
+      end
+
+      validate :options_present
+
+      def validate_present_answer(value, errors)
+        errors.add(key.to_sym, I18n.t('formblocks.errors.invalid_option')) unless Array(options).include?(value)
+      end
+
+      private
+
+      def options_present
+        errors.add(:options, :blank) if Array(options).compact_blank.empty?
+      end
+    end
+  end
+end

data/app/models/formblocks/blocks/text.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Formblocks
+  module Blocks
+    # A single-line text input. Name, Email, Phone and Url specialise it.
+    class Text < Input
+      def public_partial
+        'formblocks/public/blocks/text'
+      end
+    end
+  end
+end

data/app/models/formblocks/blocks/textarea.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Formblocks
+  module Blocks
+    class Textarea < Input
+    end
+  end
+end

data/app/models/formblocks/blocks/url.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Formblocks
+  module Blocks
+    class Url < Text
+      def self.autocomplete = 'url'
+
+      def html_input_type
+        'url'
+      end
+
+      def validate_present_answer(value, errors)
+        uri = begin
+          URI.parse(value.to_s)
+        rescue URI::InvalidURIError
+          nil
+        end
+        return if uri.is_a?(URI::HTTP) && uri.host.present?
+
+        errors.add(key.to_sym, I18n.t('formblocks.errors.invalid_url'))
+      end
+    end
+  end
+end

data/app/models/formblocks/csv_export.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Formblocks
+  # A form's responses as CSV: one column per input block (labelled), plus a
+  # column for any key a since-deleted block left behind, so nothing that
+  # was collected is lost.
+  class CsvExport
+    # Cells starting with these would be evaluated as formulas by
+    # spreadsheets; a leading apostrophe makes them text.
+    FORMULA_LEADERS = ['=', '+', '-', '@', "\t", "\r"].freeze
+
+    attr_reader :form, :responses
+
+    def initialize(form, responses = nil)
+      @form = form
+      @responses = (responses || form.responses.newest_first).to_a
+    end
+
+    def filename
+      "#{form.slug}-responses-#{Date.current.iso8601}.csv"
+    end
+
+    def generate
+      blocks = form.input_blocks
+      known = blocks.map(&:key)
+      orphans = responses.flat_map { |r| r.answers.to_h.keys }.uniq - known
+
+      CSV.generate do |csv|
+        csv << [I18n.t('formblocks.responses.csv.submitted_at'), *blocks.map do |b|
+          b.label.presence || b.key
+        end, *orphans]
+        responses.each do |response|
+          cells = blocks.map { |b| b.display_answer(response.answer(b)) } +
+                  orphans.map { |key| response.answers.to_h[key].to_s }
+          csv << [response.created_at.iso8601, *cells.map { |cell| self.class.safe(cell) }]
+        end
+      end
+    end
+
+    def self.safe(value)
+      value = value.to_s
+      FORMULA_LEADERS.any? { |leader| value.start_with?(leader) } ? "'#{value}" : value
+    end
+  end
+end