active_canvas 0.0.5 → 0.1.0

data/app/models/active_canvas/collection_item.rb

@@ -0,0 +1,66 @@
+module ActiveCanvas
+  class CollectionItem < ApplicationRecord
+    belongs_to :collection
+    has_many :versions, class_name: "ActiveCanvas::CollectionItemVersion", dependent: :destroy
+
+    attribute :data, default: {}
+    attribute :draft_data, default: {}
+
+    validates :status, inclusion: { in: %w[draft published] }
+
+    scope :published, -> { where(status: "published") }
+    scope :draft, -> { where(status: "draft") }
+
+    # Coerce raw form input (string keys = field ids) into draft_data using the
+    # collection schema. Unknown fields are dropped; each value is type-coerced.
+    def assign_fields(raw)
+      self.draft_data = draft_data.merge(schema.coerce_all_for_storage(raw))
+    end
+
+    def pending_changes?
+      ids = schema.field_ids
+      draft_data.slice(*ids) != data.slice(*ids)
+    end
+
+    # What the admin grid shows: the public snapshot for published items,
+    # the draft for everything else.
+    def effective_data
+      status == "published" ? data : draft_data
+    end
+
+    # Copies the draft into the public snapshot and records a version. The row
+    # lock serializes concurrent publishes so version numbers stay monotonic.
+    # Call on a saved record: with_lock reloads it. Returns false with an error
+    # when a required field is blank. The draft is normalized to the same
+    # snapshot, so pending_changes? is false right after publishing.
+    def publish
+      published = false
+      with_lock do
+        snapshot = schema.coerce_all_for_storage(draft_data)
+        missing = schema.missing_required_labels(snapshot)
+        if missing.any?
+          errors.add(:base, "Fill in the required fields before publishing: #{missing.join(", ")}")
+        else
+          update!(data: snapshot, draft_data: snapshot, status: "published", published_at: Time.current)
+          versions.create!(data: data, changed_by: Current.editor)
+          published = true
+        end
+      end
+      published
+    end
+
+    def publish!
+      publish || raise(ActiveRecord::RecordInvalid.new(self))
+    end
+
+    def unpublish!
+      with_lock { update!(status: "draft") }
+    end
+
+    private
+
+    def schema
+      CollectionSchema.new(collection.fields)
+    end
+  end
+end

data/app/models/active_canvas/collection_item_version.rb

@@ -0,0 +1,18 @@
+module ActiveCanvas
+  class CollectionItemVersion < ApplicationRecord
+    belongs_to :collection_item
+
+    attribute :data, default: {}
+
+    validates :version_number, presence: true, uniqueness: { scope: :collection_item_id }
+
+    before_validation :set_version_number, on: :create
+
+    private
+
+    def set_version_number
+      return if version_number.present?
+      self.version_number = (collection_item.versions.maximum(:version_number) || 0) + 1
+    end
+  end
+end

data/app/models/active_canvas/current.rb

@@ -1,6 +1,8 @@
 module ActiveCanvas
   class Current < ActiveSupport::CurrentAttributes
     attribute :settings_cache
+    # Display name of the admin user making the request; recorded on versions.
+    attribute :editor
 
     def settings_cache
       super || (self.settings_cache = {})

data/app/models/active_canvas/form_submission.rb

@@ -0,0 +1,9 @@
+module ActiveCanvas
+  class FormSubmission < ApplicationRecord
+    belongs_to :page
+
+    attribute :data, default: {}
+
+    validates :form_key, presence: true
+  end
+end

data/app/models/active_canvas/page.rb

@@ -2,33 +2,56 @@ module ActiveCanvas
   class Page < ApplicationRecord
     belongs_to :page_type
     has_many :versions, class_name: "ActiveCanvas::PageVersion", dependent: :destroy
+    has_many :redirects, class_name: "ActiveCanvas::PageRedirect", dependent: :destroy
+    has_many :form_submissions, class_name: "ActiveCanvas::FormSubmission", dependent: :destroy
+
+    # bindings column is JSON; ensure default and not-null at the model level too.
+    attribute :bindings, default: {}
 
     validates :title, presence: true
     validates :slug, uniqueness: true, allow_blank: true
+    validate :bindings_shape
 
     before_save :set_default_slug
     before_save :normalize_slug
     before_save :sanitize_content_if_enabled
     after_update :create_version_if_content_changed
+    after_save :manage_slug_redirects, if: :saved_change_to_slug?
 
     scope :published, -> { where(published: true) }
     scope :draft, -> { where(published: false) }
 
-    # Thread-local storage for tracking who made the change
-    thread_cattr_accessor :current_editor
-
     def to_param
       id&.to_s
     end
 
-    def rendered_content
-      ActiveCanvas::ContentRenderer.resolve(content).to_s.html_safe
+    def rendered_content(form_feedback: nil, form_action: nil)
+      rendered = ActiveCanvas::TemplateRenderer.new(self, mode: :public).render
+      rendered = ActiveCanvas::ContentRenderer.resolve(rendered).to_s
+      ActiveCanvas::FormStamper.new(rendered, page: self, feedback: form_feedback, action: form_action).stamp.html_safe
     end
 
     def current_version_number
       versions.maximum(:version_number) || 0
     end
 
+    # An unsaved copy carrying the editor's current state, for previews. Same
+    # id, so form tokens and media references resolve like the real page.
+    # Sanitized the way a save would be, so a static preview never shows raw
+    # markup that saving would have stripped.
+    def preview_with(content: nil, bindings: nil, content_css: nil, content_js: nil, template_enabled: nil)
+      # dup marks every attribute dirty, so the sanitizer below re-runs on the copy; that is idempotent and intended.
+      dup.tap do |preview|
+        preview.id = id
+        preview.content = content unless content.nil?
+        preview.bindings = bindings unless bindings.nil?
+        preview.content_css = content_css unless content_css.nil?
+        preview.content_js = content_js unless content_js.nil?
+        preview.template_enabled = template_enabled unless template_enabled.nil?
+        preview.sanitize_content_if_enabled
+      end
+    end
+
     # Header/footer display (with fallback for when columns don't exist yet)
     def show_header?
       return true unless self.class.column_names.include?("show_header")
@@ -50,10 +73,28 @@ module ActiveCanvas
       self.slug = slug.parameterize if slug.present?
     end
 
+    # bindings is `{ "name" => { "source" => "...", ... } }`. Anything else
+    # would blow up inside BindingResolver on the public page, so refuse it here.
+    def bindings_shape
+      return errors.add(:bindings, "must be a JSON object") unless bindings.is_a?(Hash)
+
+      bindings.each do |name, spec|
+        source = spec.is_a?(Hash) ? (spec["source"] || spec[:source]) : nil
+        errors.add(:bindings, "entry #{name.to_s.inspect} must be an object with a source") if source.to_s.blank?
+      end
+    end
+
+    protected
+
+    # Dynamic pages are sanitized after Liquid renders (see TemplateRenderer):
+    # sanitizing the source would move tags out of tables and mangle `<`.
+    # When dynamic rendering is switched off, the stored content is sanitized
+    # on that save so nothing unsanitized is ever served raw. Also called by
+    # `preview_with` on another instance, so it must be protected, not private.
     def sanitize_content_if_enabled
       return unless ActiveCanvas.config.sanitize_content
 
-      if content_changed?
+      if !template_enabled? && (content_changed? || template_enabled_changed?)
         self.content = ContentSanitizer.sanitize_html(content)
       end
 
@@ -62,24 +103,44 @@ module ActiveCanvas
       end
     end
 
+    private
+
     def create_version_if_content_changed
-      return unless saved_change_to_content? || saved_change_to_content_css?
+      content_changed_now  = saved_change_to_content?
+      css_changed_now      = saved_change_to_content_css?
+      bindings_changed_now = saved_change_to_bindings?
+      return unless content_changed_now || css_changed_now || bindings_changed_now
 
       versions.create!(
-        content_before: content_before_last_save,
-        content_after: content,
-        css_before: content_css_before_last_save,
-        css_after: content_css,
-        changed_by: self.class.current_editor,
-        change_summary: generate_change_summary
+        content_before:  content_before_last_save,
+        content_after:   content,
+        css_before:      content_css_before_last_save,
+        css_after:       content_css,
+        bindings_before: bindings_before_last_save,
+        bindings_after:  bindings,
+        changed_by:      Current.editor,
+        change_summary:  generate_change_summary
       )
     end
 
     def generate_change_summary
       changes = []
-      changes << "content updated" if saved_change_to_content?
-      changes << "CSS updated" if saved_change_to_content_css?
+      changes << "content updated"  if saved_change_to_content?
+      changes << "CSS updated"      if saved_change_to_content_css?
+      changes << "bindings updated" if saved_change_to_bindings?
       changes.join(", ").presence || "Updated"
     end
+
+    def manage_slug_redirects
+      old_slug, new_slug = saved_change_to_slug
+
+      # A slug now owned by a real page must not redirect elsewhere.
+      PageRedirect.where(from_slug: new_slug).delete_all if new_slug.present?
+
+      return unless published? && old_slug.present?
+
+      redirect = PageRedirect.find_or_initialize_by(from_slug: old_slug)
+      redirect.update!(page: self)
+    end
   end
 end

data/app/models/active_canvas/page_redirect.rb

@@ -0,0 +1,7 @@
+module ActiveCanvas
+  class PageRedirect < ApplicationRecord
+    belongs_to :page
+
+    validates :from_slug, presence: true, uniqueness: true
+  end
+end

data/app/services/active_canvas/collection_schema.rb

@@ -0,0 +1,110 @@
+require "date"
+
+module ActiveCanvas
+  # Pure value object over a Collection's `fields` array. Coerces raw input for
+  # JSON storage and stored values for Liquid. The single source of truth for
+  # per-type conversion, shared by CollectionItem (write) and CollectionSource (read).
+  class CollectionSchema
+    VALID_FIELD_TYPES = %w[text textarea rich_text number boolean date select media].freeze
+
+    def self.generate_field_id(label, taken)
+      base = label.to_s.parameterize(separator: "_").tr("-", "_").squeeze("_").gsub(/\A_+|_+\z/, "").presence || "field"
+      base = "f_#{base}" unless base.match?(/\A[a-z]/)
+      candidate = base
+      counter = 1
+      while taken.include?(candidate)
+        counter += 1
+        candidate = "#{base}_#{counter}"
+      end
+      candidate
+    end
+
+    def initialize(fields)
+      @fields = (fields || []).map { |f| f.transform_keys(&:to_s) }
+    end
+
+    def field_ids
+      @fields.map { |f| f["id"] }
+    end
+
+    def field(id)
+      @fields.find { |f| f["id"] == id.to_s }
+    end
+
+    def coerce_for_storage(field_id, value)
+      spec = field(field_id)
+      return nil unless spec
+
+      case spec["type"]
+      when "number"    then coerce_number(value)
+      when "boolean"   then ActiveModel::Type::Boolean.new.cast(value) || false
+      when "date"      then coerce_date(value)
+      when "rich_text" then ContentSanitizer.sanitize_html(value.to_s)
+      when "media"     then value.presence && value.to_i
+      when "select"    then Array(spec["options"]).include?(value.to_s) ? value.to_s : nil
+      else value.to_s.presence
+      end
+    end
+
+    # Coerces every schema field present in `raw`; unknown keys are dropped.
+    # Used both for form input and to rebuild the published snapshot, so data
+    # written around assign_fields (console, seeds) is still sanitized.
+    # A select value whose option was removed becomes nil, so a required
+    # select can stop a previously valid draft from publishing until it is
+    # edited.
+    def coerce_all_for_storage(raw)
+      raw = (raw || {}).transform_keys(&:to_s)
+      field_ids.each_with_object({}) do |id, acc|
+        acc[id] = coerce_for_storage(id, raw[id]) if raw.key?(id)
+      end
+    end
+
+    # Labels of required fields with no value. Booleans are never "missing":
+    # false is a value.
+    def missing_required_labels(data)
+      data = (data || {}).transform_keys(&:to_s)
+      @fields.select { |f| f["required"] && f["type"] != "boolean" && data[f["id"]].blank? }.map { |f| f["label"] }
+    end
+
+    # Values handed to Liquid. Text is HTML-escaped here; rich_text was
+    # sanitized on write and is marked html_safe so the resolver leaves it alone.
+    def coerce_for_liquid(field_id, value, media_urls: nil)
+      spec = field(field_id)
+      return nil unless spec
+
+      case spec["type"]
+      when "number", "boolean" then value
+      when "date"      then (Date.iso8601(value.to_s) rescue nil)
+      when "rich_text" then value.to_s.html_safe
+      when "media"     then ERB::Util.html_escape(resolve_media_url(value, media_urls))
+      else ERB::Util.html_escape(value.to_s)
+      end
+    end
+
+    private
+
+    def coerce_number(value)
+      return value if value.is_a?(Numeric)
+      return nil if value.to_s.strip.empty?
+      Integer(value)
+    rescue ArgumentError, TypeError
+      begin
+        Float(value)
+      rescue ArgumentError, TypeError
+        nil
+      end
+    end
+
+    def coerce_date(value)
+      return nil if value.to_s.strip.empty?
+      Date.parse(value.to_s).iso8601
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def resolve_media_url(value, media_urls)
+      return media_urls[value].to_s if media_urls
+      ActiveCanvas::Media.find_by(id: value)&.url.to_s
+    end
+  end
+end

data/app/services/active_canvas/collection_source.rb

@@ -0,0 +1,81 @@
+module ActiveCanvas
+  # Resolves a Collection into Liquid-safe row hashes for a dynamic-data loop.
+  # Loads published items, applies equality filter / sort / limit, and maps each
+  # item's stored data through the collection schema's Liquid coercion.
+  class CollectionSource
+    DEFAULT_LIMIT = 100
+    MAX_LIMIT = 500
+
+    def initialize(collection)
+      @collection = collection
+      @schema = CollectionSchema.new(collection.fields)
+    end
+
+    def resolve(params = {})
+      params = (params || {}).transform_keys(&:to_s)
+      items = @collection.items.published.to_a
+      items = filter(items, params)
+      items = sort(items, params)
+      items = items.first(clamped_limit(params))
+      media_urls = preload_media_urls(items)
+      items.map { |item| row(item, media_urls) }
+    end
+
+    private
+
+    def filter(items, params)
+      field = params["filter_field"]
+      value = params["filter_value"]
+      return items unless field.present? && value.present? && @schema.field(field)
+
+      items.select { |item| item.data[field].to_s == value.to_s }
+    end
+
+    def sort(items, params)
+      spec = @schema.field(params["sort_field"]) if params["sort_field"].present?
+      return items.sort_by { |item| [ item.published_at || Time.at(0), item.id ] }.reverse unless spec
+
+      sortable, unsortable = items.partition { |item| sortable?(spec, item.data[spec["id"]]) }
+      sorted = sortable.sort_by { |item| [ sort_key(spec, item.data[spec["id"]]), item.id ] }
+      sorted.reverse! unless params["sort_dir"] == "asc"
+      sorted + unsortable.sort_by(&:id) # nils and unreadable values go last both ways
+    end
+
+    def sortable?(spec, value)
+      case spec["type"]
+      when "number"  then value.is_a?(Numeric)
+      when "boolean" then !value.nil?
+      else value.present?
+      end
+    end
+
+    def sort_key(spec, value)
+      case spec["type"]
+      when "number"  then value
+      when "boolean" then value ? 1 : 0
+      else value.to_s.downcase # dates are ISO-8601, so lexical order is chronological
+      end
+    end
+
+    def clamped_limit(params)
+      limit = Integer(params["limit"], exception: false) if params["limit"].present?
+      limit = DEFAULT_LIMIT if limit.nil? || limit <= 0
+      [ limit, MAX_LIMIT ].min
+    end
+
+    def preload_media_urls(items)
+      media_ids = @schema.field_ids.select { |id| @schema.field(id)["type"] == "media" }
+      return {} if media_ids.empty?
+
+      ids = items.flat_map { |item| media_ids.map { |fid| item.data[fid] } }.compact.uniq
+      ActiveCanvas::Media.where(id: ids).index_by(&:id).transform_values(&:url)
+    end
+
+    def row(item, media_urls)
+      base = { "id" => item.id, "slug" => item.slug, "published_at" => item.published_at }
+      @schema.field_ids.each_with_object(base) do |field_id, acc|
+        acc[field_id] = @schema.coerce_for_liquid(field_id, item.data[field_id], media_urls: media_urls)
+      end
+    end
+  end
+end

data/app/services/active_canvas/content_sanitizer.rb

@@ -1,7 +1,15 @@
+require "securerandom"
+
 module ActiveCanvas
   class ContentSanitizer
     class << self
-      # Sanitize HTML content using Rails' built-in sanitizer
+      LIQUID_TAG = /\{\{[\s\S]*?\}\}|\{%[\s\S]*?%\}/
+
+      # Sanitize HTML content using Rails' built-in sanitizer. Liquid tags are
+      # masked first: the HTML parser would otherwise percent-encode `{{ url }}`
+      # inside an href and read `{% if a < b %}` as markup. A tag inside a
+      # dropped attribute or tag is dropped with it, so masking never unlocks
+      # anything the sanitizer would refuse.
       def sanitize_html(content)
         return content if content.blank?
         return content unless ActiveCanvas.config.sanitize_content
@@ -17,7 +25,10 @@ module ActiveCanvas
           allowed_attributes: config.allowed_html_attributes
         )
 
-        sanitizer.sanitize(content, scrubber: scrubber)
+        tags = []
+        nonce = SecureRandom.hex(4)
+        masked = content.gsub(LIQUID_TAG) { tags << $& ; "acliquid#{nonce}n#{tags.size - 1}z" }
+        sanitizer.sanitize(masked, scrubber: scrubber).gsub(/acliquid#{nonce}n(\d+)z/) { tags[$1.to_i] }
       end
 
       # Sanitize CSS content (basic XSS protection)
@@ -59,6 +70,11 @@ module ActiveCanvas
 
     # Custom scrubber that allows data-* and aria-* attributes
     class PermissiveAttributeScrubber < Rails::HTML::PermitScrubber
+      # Never restored after Loofah's scrub: browsers tolerate whitespace and
+      # control characters inside URL schemes, so any check of our own would
+      # be weaker than Loofah's. Loofah is the sole authority on URLs.
+      URL_ATTRIBUTES = %w[href src action formaction xlink:href poster].freeze
+
       def initialize(allowed_tags:, allowed_attributes:)
         super()
         self.tags = allowed_tags
@@ -70,30 +86,26 @@ module ActiveCanvas
         true
       end
 
-      def scrub_attribute(node, attr_node)
-        attr_name = attr_node.name.downcase
-
-        # Allow explicitly listed attributes
-        return if @allowed_attributes.include?(attr_name)
-
-        # Allow data-* attributes
-        return if attr_name.start_with?("data-")
+      # PermitScrubber only honors an explicit attribute list when
+      # `self.attributes` is set; otherwise it defers to Loofah's built-in
+      # safelist, which drops attributes we explicitly allow (e.g. `required`).
+      # Keep Loofah's security scrubbing, then restore what our config permits.
+      def scrub_attributes(node)
+        restorable = node.attribute_nodes.select { |attr| explicitly_allowed?(attr) }.to_h { |attr| [ attr.name, attr.value ] }
+        super
+        restorable.each { |name, value| node[name] = value unless node.attributes.key?(name) }
+      end
 
-        # Allow aria-* attributes
-        return if attr_name.start_with?("aria-")
+      private
 
-        # Check for dangerous attribute values (javascript: URLs, event handlers)
-        if dangerous_attribute?(attr_name, attr_node.value)
-          attr_node.remove
-          return
-        end
+      def explicitly_allowed?(attr_node)
+        name = attr_node.name.downcase
+        return false if URL_ATTRIBUTES.include?(name)
+        return false if dangerous_attribute?(name, attr_node.value)
 
-        # Remove unlisted attributes
-        attr_node.remove
+        @allowed_attributes.include?(name) || name.start_with?("data-", "aria-")
       end
 
-      private
-
       def dangerous_attribute?(name, value)
         # Event handlers
         return true if name.start_with?("on")

data/app/services/active_canvas/form_schema.rb

@@ -0,0 +1,48 @@
+module ActiveCanvas
+  # Derives a form's definition from a page's saved content. The markup IS the
+  # definition: only fields present in the authored <form> are accepted, and
+  # `required` attributes drive validation. Shared key derivation keeps the
+  # stamper and the endpoint pointing at the same form.
+  class FormSchema
+    INTERNAL_PREFIX = "ac_".freeze
+    EXCLUDED_TYPES = %w[file submit button image reset].freeze
+
+    Schema = Struct.new(:fields, :required)
+
+    class << self
+      def forms(html)
+        Nokogiri::HTML5.fragment(html.to_s).css("form").each_with_index.map do |form, index|
+          [ key_for(form, index), form ]
+        end
+      end
+
+      def keys(html)
+        forms(html).map(&:first)
+      end
+
+      def derive(html, form_key)
+        _, form = forms(html).find { |key, _| key == form_key }
+        return nil unless form
+
+        controls = form.css("input, select, textarea").select { |node| accepted?(node) }
+        Schema.new(
+          controls.map { |node| node["name"] }.uniq,
+          controls.select { |node| node.has_attribute?("required") }.map { |node| node["name"] }.uniq
+        )
+      end
+
+      def key_for(form, index)
+        form["name"].presence || form["id"].presence || "form-#{index + 1}"
+      end
+
+      private
+
+      def accepted?(node)
+        name = node["name"]
+        name.present? &&
+          !name.start_with?(INTERNAL_PREFIX) &&
+          !EXCLUDED_TYPES.include?(node["type"].to_s.downcase)
+      end
+    end
+  end
+end

data/app/services/active_canvas/form_stamper.rb

@@ -0,0 +1,86 @@
+module ActiveCanvas
+  # Arms authored <form> elements at render time: points them at the engine's
+  # public endpoint, injects the signed anti-spam token and honeypot, and
+  # drives the no-JS success/error feedback via query params. Idempotent:
+  # engine-injected nodes are replaced, never duplicated.
+  class FormStamper
+    HONEYPOT_FIELD = "ac_website".freeze
+    TOKEN_FIELD = "ac_token".freeze
+    TOKEN_EXPIRY = 1.week
+
+    ERROR_MESSAGES = {
+      "missing_fields" => "Please fill in all required fields.",
+      "too_fast" => "That was too quick — please try again.",
+      "invalid" => "Something went wrong. Please try again."
+    }.freeze
+
+    def self.verifier
+      Rails.application.message_verifier("active_canvas/forms")
+    end
+
+    def self.token_for(page:, form_key:, issued_at: Time.current)
+      verifier.generate(
+        { "page_id" => page.id, "form_key" => form_key, "issued_at" => issued_at.to_f },
+        expires_in: TOKEN_EXPIRY
+      )
+    end
+
+    # action: the mounted submissions path from the request context
+    # (engine route helpers outside a request don't know the mount point).
+    def initialize(html, page:, feedback: nil, action: nil)
+      @html = html.to_s
+      @page = page
+      @feedback = feedback || {}
+      @action = action || Engine.routes.url_helpers.public_form_submissions_path
+    end
+
+    def stamp
+      return @html unless @html.include?("<form")
+
+      doc = Nokogiri::HTML5.fragment(@html)
+      doc.css("form").each_with_index do |form, index|
+        arm(form, FormSchema.key_for(form, index))
+      end
+      doc.to_html
+    end
+
+    private
+
+    def arm(form, form_key)
+      form["action"] = @action
+      form["method"] = "post"
+
+      form.css("input[name^='ac_']").each(&:remove)
+      form.add_child(hidden_input(TOKEN_FIELD, self.class.token_for(page: @page, form_key: form_key)))
+      form.add_child(honeypot_input)
+
+      ensure_feedback_element(form, "data-ac-success", "Thank you!")
+      ensure_feedback_element(form, "data-ac-error", ERROR_MESSAGES["invalid"])
+      apply_feedback(form, form_key)
+    end
+
+    def hidden_input(name, value)
+      %(<input type="hidden" name="#{name}" value="#{CGI.escapeHTML(value)}">)
+    end
+
+    def honeypot_input
+      %(<input type="text" name="#{HONEYPOT_FIELD}" value="" style="position:absolute;left:-9999px" tabindex="-1" autocomplete="off">)
+    end
+
+    def ensure_feedback_element(form, attribute, default_text)
+      element = form.at_css("[#{attribute}]")
+      element ||= form.add_child(%(<div #{attribute}>#{default_text}</div>)).first
+      element["hidden"] = ""
+    end
+
+    def apply_feedback(form, form_key)
+      if @feedback[:submitted] == form_key
+        form.at_css("[data-ac-success]").remove_attribute("hidden")
+      elsif @feedback[:error].present? && @feedback[:form_key] == form_key
+        error = form.at_css("[data-ac-error]")
+        error.content = ERROR_MESSAGES.fetch(@feedback[:error], ERROR_MESSAGES["invalid"])
+        error.remove_attribute("hidden")
+      end
+    end
+  end
+end