forme 1.8.0 → 1.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd9180036757136c1db6fac34b523812491b687be4395d87ef09efee4066d85b
-  data.tar.gz: a627b8fdde2c50d73e28b9a7d9d66545de2df0e180dd06832beea3c4990db04c
+  metadata.gz: f9ee8a7a7efaf9ff59c55404e6c11aba0125cdf59972366b94aa3359b06c6c1f
+  data.tar.gz: dd9f90ad552c827b66a3d8146f8933e5258b34ece1db5a8a9515ac9e2aeada44
 SHA512:
-  metadata.gz: 489e5bf2d0d1d3af91e85c36e864775395ff6aede61c591e519c951118add014491e6b9d1b01e10364408fafcc8cc51aeffdcf43a21ea8fe2f247e0932d6acd7
-  data.tar.gz: f6aa875870c75b068b2fd91846f2deba8e3f3304797c945895469e0903797ad0a9eb7a425b8185a3e707e13f30c02f3cb879a43c0d412b1c09f630d9eeefc526
+  metadata.gz: 5867cc14f49ea0a2419e4f7d30a518a8886753f11e4e6af46f7565106ef54869c9bf9d5ba691f7f08ee7fab5d729bb16e8b1463939dc043d7e91aeb5e8bf1f2e
+  data.tar.gz: 25bf44d57e37ef994cab9a6c2bf532b4dddd209fff6b1542b21596e2cdbfa1e20a1ae04af9d2b4c0ad113f322c06fe1e8a662a4d2facd36439f2c1a45d2e4250

data/CHANGELOG

@@ -1,3 +1,53 @@
+=== 1.12.0 (2021-08-25)
+
+* Make forme_set Sequel plugin handle frozen Sequel::Model instances (jeremyevans)
+
+* Do not override an error on a field when using the Sequel plugin if :error option is already given (jeremyevans)
+
+* Avoid error when creating label text when using Sequel input on non-Sequel form without an explicit :label option (jeremyevans)
+
+* Make :select_options option for date/datetime selects support providing both option texts and option values using a 2 element array (jeremyevans)
+
+=== 1.11.0 (2020-01-03)
+
+* Add Roda forme_set plugin, using HMACed form metadata to automatically handle submitted form parameters (jeremyevans)
+
+=== 1.10.0 (2019-05-13)
+
+* Make readonly formatter ignore hidden inputs (jeremyevans)
+
+* Add :select_labels for date inputs using :as=>:select to use labels for the inputs for better accessibility (jeremyevans)
+
+* Add :after_legend error_handler for adding error message after legend when using :legend labeler (jeremyevans)
+
+* Add aria-describedby to all inputs with errors where possible for better accessibility (jeremyevans)
+
+* Add aria-invalid to all inputs with errors for better accessibility (jeremyevans)
+
+* Support :fieldset wrapper and :legend labeler, can be used for accessible radioset/checkboxset (jeremyevans)
+
+* Support :tag_label_attr option for radioset and checkbox set for label attributes for each radio/checkbox label (jeremyevans)
+
+* Support custom :error_handler in radioset and checkboxset inputs (jeremyevans)
+
+* Support custom :labeler in radioset and checkboxset inputs (jeremyevans)
+
+* Avoid calling Proc.new with an implicit block, which is deprecated starting in ruby 2.7 (jeremyevans)
+
+=== 1.9.0 (2018-11-16)
+
+* Automatically add maxlength attributes to text and textarea inputs in the Sequel plugin based on maximum database column length (jeremyevans)
+
+* Make forme_set Sequel plugin recognize default formatter changes set via with_opts (jeremyevans)
+
+* Use div with nested p tags instead of spans for readonly textarea inputs (jeremyevans)
+
+* Make readonly text input spans use the readonly-text class for easier styling (jeremyevans)
+
+* Add Forme.h for HTML escaping, using cgi/escape if available for faster escaping (jeremyevans)
+
+* Correctly handle :value=>false option and false option values in select, radioset, and checkboxset inputs (jeremyevans)
+
 === 1.8.0 (2018-06-11)
 
 * Add support for :errors form option for setting error information for multiple inputs, similar to :values form option (adam12) (#32)

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2018 Jeremy Evans
+Copyright (c) 2011-2021 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README.rdoc

@@ -101,8 +101,7 @@ by creating your own transformer and then calling the existing transformer.
 Demo Site :: http://forme-demo.jeremyevans.net
 RDoc :: http://forme.jeremyevans.net
 Source :: https://github.com/jeremyevans/forme
-IRC :: irc://irc.freenode.net/forme
-Google Group :: https://groups.google.com/forum/#!forum/ruby-forme
+Discussion Forum :: https://github.com/jeremyevans/forme/discussions
 Bug Tracker :: https://github.com/jeremyevans/forme/issues
 
 = Basic Usage
@@ -589,7 +588,7 @@ As you can see, you basically need to recreate the conditionals used when creati
 the form, so that that the processing of the form submission handles only the
 inputs that were displayed on the form.
 
-=== forme_set plugin
+=== forme_set Sequel plugin
 
 The forme_set plugin is designed to make handling form submissions easier.  What it does
 is record the form fields that are used on the object, and then it uses those fields
@@ -686,6 +685,166 @@ internally).  forme_parse returns a hash with the following keys:
 It is possible to use forme_set for the values it can handle, and set other fields manually
 using set_fields.
 
+=== forme_set Roda plugin
+
+The forme_set Roda plugin builds on the forme_set Sequel plugin and is designed to make
+handling form submissions even easier. This plugin uses a hidden form input to store which
+fields were used to build the form, as well as some other metadata.  It uses another hidden
+form input with an HMAC, so that on submission, if the HMAC matches, you can be sure that an
+attacker didn't add extra fields.
+
+There are a couple advantages to this plugin over using just the Sequel forme_set plugin.
+One is that you do not need to record the form fields when processing the submission of a
+form, since the information you need is included in the form submission. Another is that
+calling the forme_set method is simpler, since it can determine the necessary parameters.
+
+While you need code like this when using just the Sequel forme_set plugin:
+
+  album = Album[1]
+  Forme.form(album, :action=>'/foo') do |f|
+    f.input :name
+    f.input :copies_sold if album.released?
+  end
+  album.forme_set(params['album'])
+
+when you also use the Roda forme_set plugin, you can simplify it to:
+
+  album = Album[1]
+  forme_set(album)
+
+==== Validations
+
+The Roda forme_set plugin supports and uses the same validations as the Sequel forme_set
+plugin.  However, the Roda plugin is more accurate because it uses the options that were
+present on the form when it was originally built, instead of the options that would be
+present on the form when the form was submitted.  However, note that that can be a
+negative if you are dynamically adding values to both the database and the form between
+when the form was built and when it was submitted.
+
+==== Usage
+
+Because the Roda forme_set plugin includes the metadata needed to process the form in form
+submissions, you don't need to rearrange code to use it, or rerender templates.
+You can do:
+
+  album = Album[1]
+  forme_set(album)
+
+And the method will update the +album+ object using the appropriate form values. 
+
+Note that using the Roda forme_set plugin requires you set a secret for the HMAC.  It
+is important that you keep this value secret, because if an attacker has access to this,
+they would be able to set arbitrary attributes for model objects.  In your Roda class,
+you can load the plugin via:
+
+  plugin :forme_set, :secret => ENV["APP_FORME_HMAC_SECRET"]
+
+By default, invalid form submissions will raise an exception.  If you want to change
+that behavior (i.e. to display a nice error page), pass a block when loading the plugin:
+
+  plugin :forme_set do |error_type, obj|
+    # ...
+  end
+
+The block arguments will be a symbol for the type of error (:missing_data, :missing_hmac,
+:hmac_mismatch, :csrf_mismatch, or :missing_namespace) and the object passed to +forme_set+.
+This block should raise or halt.  If it does not, the default behavior of raising an
+exception will be taken.
+
+=== Form Versions
+
+The Roda forme_set plugin supports form versions.  This allows you to gracefully handle
+changes to forms, processing submissions of the form generated before the change (if
+possible) as well as the processing submissions of the form generated after the change.
+
+For example, maybe you have an existing form with just an input for the name:
+
+  form(album) do |f|
+    f.input(:name)
+  end
+
+Then later, you want to add an input for the number of copies sold:
+
+  form(album) do |f|
+    f.input(:name)
+    f.input(:copies_sold)
+  end
+
+Using the Roda forme_set plugin, submissions of the old form would only set the
+name field, it wouldn't set the copies_sold field, since when the form was created,
+only the name field was used.
+
+You can handle this case be versioning the form when making changes to it:
+
+  form(album, {}, :form_version=>1) do |f|
+    f.input(:name)
+    f.input(:copies_sold)
+  end
+
+When you are processing the form submission with forme_set, you pass a block, which
+will be yielded the version for the form (nil if no version was set):
+
+  forme_set(album) do |version|
+    if version == nil
+      album.copies_sold = 0
+    end
+  end
+
+The block is also yielded the object passed for forme_set, useful if you don't keep
+a reference to it:
+
+  album = forme_set(Album.new) do |version, obj|
+    if version == nil
+      obj.copies_sold = 0
+    end
+  end
+
+You only need to support old versions of the form for as long as their could be
+active sessions that could use the old versions of the form.  As long you as
+are expiring sessions to prevent session fixation, you can remove the version
+handling after the expiration period has passed since the change to the form
+was made.
+
+Note that this issue with handling changes to forms is not specific to the Roda
+forme_set plugin, it affects pretty much all form submissions.  The Roda forme_set
+plugin just makes this issue easier to handle.
+
+==== Caveats
+
+The Roda forme_set plugin has basically the same caveats as Sequel forme_set plugin.
+Additionally, it has a couple other restrictions that the Sequel forme_set plugin
+does not have.
+
+First, the Roda forme_set plugin only handles a single object in forms,
+which must be provided when creating the form.  It does not handle multiple
+objects in the same form, and ignores any fields set for an object different
+from the one passed when creating the form.  You can use the Sequel forme_set
+plugin to handle form submissions involving multiple objects, or for the
+objects that were not passed when creating the form.
+
+Second, the Roda forme_set plugin does not handle cases where the field values
+are placed outside the forms default namespace.  The Sequel forme_set plugin
+can handle those issues, as long as all values are in the same namespace, since
+the Sequel forme_set plugin requires you pass in the specific hash to use (the
+Roda forme_set plugin use the form's namespace information and the submitted
+parameters to determine the hash to use).
+
+In cases where the Roda forme_set does not handle things correctly, you can use
+forme_parse, which will return metadata in the same format as the Sequel plugin
+forme_parse method, with the addition of a :form_version key in the hash for the
+form version.
+
+It is possible to use the Roda forme_set plugin for the submissions it can handle, the
+Sequel forme_set plugin for the submissions it can handle, and set other fields manually
+using the Sequel set_fields methods.
+
+Note that when using the Roda forme_set plugin with an existing form, you should first
+enable the Roda plugin without actually using the Roda forme_set method.  Do not
+start using the Roda forme_set method until all currently valid sessions were
+established after the Roda forme_set plugin was enabled.  Otherwise, sessions that
+access the form before the Roda forme_set plugin was enabled will not work if they
+submit the form after the Roda forme_set plugin is enabled.
+
 == Other Sequel Plugins
 
 In addition to the Sequel plugins mentioned above, Forme also ships with additional Sequel
@@ -695,9 +854,9 @@ forme_i18n :: Handles translations for labels using i18n.
 
 = Roda Support
 
-Forme ships with two Roda plugins, forme and forme_route_csrf.  For new code, it is
-recommended to use forme_route_csrf, as that uses Roda's route_csrf plugin, which
-supports more secure request-specific CSRF tokens.  In both cases, usage in ERB
+Forme ships with three Roda plugins: forme_set (discussed above), forme, and forme_route_csrf.
+For new code, it is recommended to use forme_route_csrf, as that uses Roda's route_csrf
+plugin, which supports more secure request-specific CSRF tokens.  In both cases, usage in ERB
 templates is the same:
 
   <% form(@obj, :action=>'/foo') do |f| %>
@@ -780,6 +939,7 @@ These options are supported by all of the input types:
 :disabled :: Set the disabled attribute if true
 :error :: Set an error message, invoking the error_handler
 :error_handler :: Set a custom error_handler, overriding the form's default
+:help :: Set help text to use, invoking the helper
 :helper :: Set a custom helper, overriding the form's default
 :id :: The id attribute to use
 :key :: The base to use for the name and id attributes, based on the current
@@ -822,8 +982,13 @@ creates multiple select options. Options:
           for the select field and string to use a string
           (:date default: <tt>[:year, '-', :month, '-', :day]</tt>)
           (:datetime default: <tt>[:year, '-', :month, '-', :day, ' ', :hour, ':', :minute, ':', :second]</tt>)
+:select_labels :: The labels to use for the select boxes.  Should be a hash keyed by the
+                  symbol used (e.g. <tt>{:month=>'Month'}</tt>).  By default, no labels are used.
 :select_options :: The options to use for the select boxes.  Should be a hash keyed by the
-                   symbol used in order (e.g. <tt>{:year=>1970..2020}</tt>)
+                   symbol used in order (e.g. <tt>{:year=>1970..2020}</tt>).  The values
+                   can be a number used as both the value and the text of the option or
+                   an array with two elements, the first of which is the value for the option
+                   and the second of which is the text for the option.
 
 === :select
 
@@ -843,7 +1008,8 @@ Creates a select tag, containing option tags specified by the :options option.
 :options :: An enumerable of options used for creating option tags.
             If the :text_method and :value_method are not given and the entry is an 
             array, uses the first entry of the array as the text of the option, and
-            the second entry of the array as the value of the option.
+            the last entry of the array as the value of the option. If the last entry
+            of the array is a hash, uses the hash as the attributes for the option.
 :selected :: The value that should be selected.  Any options that are equal to
              this value (or included in this value if a multiple select box),
              are set to selected.
@@ -862,6 +1028,7 @@ the following options:
 
 :tag_wrapper :: The wrapper transformer for individual tags in the set
 :tag_labeler :: The labeler transformer for individual tags in the set
+:tag_label_attr :: The attributes to use for labels for individual tags in the set
 
 === :radioset
 
@@ -980,7 +1147,9 @@ Forme ships with a bunch of built-in transformers that you can use:
 
 === +error_handler+
 
+:after_legend :: designed for usage with :legend labeler, putting error message after legend, adding error for first input in the set
 :default :: modifies tag to add an error class and adds a span with the error message
+:set :: default error_handler for checkboxset and radioset inputs, that adds an error to the last input in the set
 
 This supports the following options:
 
@@ -998,8 +1167,10 @@ This supports the following options:
 
 :default :: uses implicit labels, where the tag is a child of the label tag
 :explicit :: uses explicit labels with the for attribute, where tag is a sibling of the label tag
+:legend :: adds a legend before the tags, mostly useful for accessible checkboxset and radioset inputs
+:span :: default labeler for checkboxset and radioset inputs that adds a span before the tags
 
-Both of these respect the following options:
+The :default and :explicit labelers respect the following options:
 
 :label_position :: Can be set to :before or :after to place the label before or after the the input.
 :label_attr :: A hash of attributes to use for the label tag
@@ -1008,6 +1179,7 @@ Both of these respect the following options:
 
 :default :: returns tag without wrapping
 :div :: wraps tag in div tag
+:fieldset :: wraps tags in a fieldset, mostly useful for accessible checkboxset and radioset inputs
 :fieldset_ol :: same as :li, but also sets +inputs_wrapper+ to :fieldset_ol
 :li :: wraps tag in li tag
 :ol :: same as :li, but also sets +inputs_wrapper+ to :ol

data/lib/forme/bs3.rb

@@ -214,7 +214,7 @@ module Forme
           yield
         end
       else
-        form.tag(:fieldset, attr, &Proc.new)
+        form.tag(:fieldset, attr, &block)
       end
     end
   end

data/lib/forme/form.rb

@@ -59,7 +59,7 @@ module Forme
       ins = opts[:inputs]
       button = opts[:button]
       if ins || button
-        block = Proc.new do |form|
+        block = proc do |form|
           form._inputs(ins, opts) if ins
           yield form if block_given?
           form.emit(form.button(button)) if button

data/lib/forme/transformers/error_handler.rb

@@ -11,10 +11,55 @@ module Forme
 
     # Return tag with error message span tag after it.
     def call(tag, input)
+      [tag, error_tag(input)]
+    end
+
+    private
+
+    def error_tag(input)
       attr = input.opts[:error_attr]
       attr = attr ? attr.dup : {}
       Forme.attr_classes(attr, 'error_message')
-      [tag, input.tag(:span, attr, input.opts[:error])]
+
+      if id = input.opts[:error_id]
+        unless attr['id'] || attr[:id]
+          attr['id'] = id
+        end
+      end
+
+      input.tag(:span, attr, input.opts[:error])
+    end
+  end
+
+  class ErrorHandler::Set < ErrorHandler
+    Forme.register_transformer(:error_handler, :set, new)
+
+    def call(tag, input)
+      return super unless last_input = input.opts[:last_input]
+
+      last_input.opts[:error] = input.opts[:error]
+      last_input.opts[:error_attr] = input.opts[:error_attr] if input.opts[:error_attr]
+      last_input.opts[:error_handler] = :default
+
+      tag
+    end
+  end
+
+  class ErrorHandler::AfterLegend < ErrorHandler
+    Forme.register_transformer(:error_handler, :after_legend, new)
+
+    def call(tag, input)
+      return super unless tag.is_a?(Array)
+      return super unless tag.first.is_a?(Tag)
+      return super unless tag.first.type == :legend
+
+      first_input = input.opts[:first_input]
+      attr = first_input.opts[:attr] ||= {}
+      Forme.attr_classes(attr, 'error')
+      attr['aria-invalid'] = 'true'
+      attr['aria-describedby'] = input.opts[:error_id] = "#{first_input.opts[:id]}_error_message"
+
+      tag.insert(1, error_tag(input))
     end
   end
 end

data/lib/forme/transformers/formatter.rb

@@ -61,7 +61,6 @@ module Forme
       @attr = attr ? attr.dup : {}
       @opts = input.opts
       normalize_options
-
       tag = if html = input.opts[:html]
         html = html.call(input) if html.respond_to?(:call)
         form.raw(html)
@@ -158,9 +157,13 @@ module Forme
       ops = ops.merge(@opts[:select_options]) if @opts[:select_options]
       first_input = true
       format = DATE_SELECT_FORMAT
+      @opts[:select_labels] ||= {}
       order.map do |x|
         next x if x.is_a?(String)
-        opts = @opts.merge(:label=>nil, :wrapper=>nil, :error=>nil, :name=>"#{name}[#{x}]", :value=>values[x], :options=>ops[x].map{|y| [sprintf(format, y), y]})
+        options = ops[x].map do |value, text|
+          [text || sprintf(format, value), value]
+        end
+        opts = @opts.merge(:label=>@opts[:select_labels][x], :wrapper=>nil, :error=>nil, :name=>"#{name}[#{x}]", :value=>values[x], :options=>options)
         opts[:id] = if first_input
           first_input = false
           id
@@ -186,9 +189,9 @@ module Forme
       copy_options_to_attributes([:size])
 
       os = process_select_optgroups(:_format_select_optgroup) do |label, value, sel, attrs|
-        if value || sel
-         attrs = attrs.dup
-          attrs[:value] = value if value
+        if !value.nil? || sel
+          attrs = attrs.dup
+          attrs[:value] = value unless value.nil?
           attrs[:selected] = :selected if sel
         end
         tag(:option, attrs, [label])
@@ -221,24 +224,25 @@ module Forme
       key = @opts[:key]
       name = @opts[:name]
       id = @opts[:id]
-      if @opts[:error]
-        @opts[:set_error] = @opts.delete(:error)
-      end
-      if @opts[:label]
-        @opts[:set_label] = @opts.delete(:label)
-      end
+      @opts[:labeler] ||= :span
+      @opts[:error_handler] ||= :set
 
       tag_wrapper = Forme.transformer(:tag_wrapper, @opts.delete(:tag_wrapper), @input.form_opts) || :default
       tag_labeler = Forme.transformer(:labeler, @opts.delete(:tag_labeler), @input.form_opts) || :default
       wrapper = @opts.fetch(:wrapper){@opts[:wrapper] = @input.form_opts[:set_wrapper] || @input.form_opts[:wrapper]}
       wrapper = Forme.transformer(:wrapper, wrapper)
+      tag_label_attr = @opts[:tag_label_attr] || @opts[:label_attr]
 
-      tags = process_select_optgroups(:_format_set_optgroup) do |label, value, sel, attrs|
-        value ||= label
+      first_input = nil
+      last_input = nil
+      ret = process_select_optgroups(:_format_set_optgroup) do |label, value, sel, attrs|
+        value = label if value.nil?
         label_attr = {:class=>:option}
-        label_attr.merge!(@opts[:label_attr]) if @opts[:label_attr]
-        r_opts = attrs.merge(tag_attrs).merge(:label=>label||value, :label_attr=>label_attr, :wrapper=>tag_wrapper, :labeler=>tag_labeler)
-        r_opts[:value] ||= value if value
+        label_attr.merge!(tag_label_attr) if tag_label_attr
+        r_opts = attrs.merge(tag_attrs).merge(:label=>label||value, :label_attr=>label_attr, :wrapper=>tag_wrapper, :labeler=>tag_labeler, :error=>nil, :error_attr=>nil)
+        if r_opts[:value].nil?
+          r_opts[:value] = value unless value.nil?
+        end
         r_opts[:checked] ||= :checked if sel
         r_opts[:formatter] = @opts[:formatter] if @opts[:formatter]
 
@@ -253,31 +257,15 @@ module Forme
           r_opts[:key_id] ||= value
         end
 
-        form._input(type, r_opts)
+        input = form._input(type, r_opts)
+        first_input ||= input
+        last_input = input
       end
 
-      if @opts[:set_error]
-        _add_set_error(tags)
-      end
-
-      tags.unshift(set_label) if @opts[:set_label]
-
-      tags
-    end
+      @opts[:first_input] = first_input
+      @opts[:last_input] = last_input
 
-    def set_label
-      form._tag(:span, {:class=>:label}, @opts[:set_label])
-    end
-
-    def _add_set_error(tags)
-      if (last_input = tags.last) && last_input.is_a?(Input)
-        last_input.opts[:error] = @opts[:set_error]
-        last_input.opts[:error_attr] = @opts[:error_attr] if @opts[:error_attr]
-      else
-        attr = @opts[:error_attr] || {}
-        Forme.attr_classes(attr, 'error_message')
-        tags << form._tag(:span, attr, [@opts[:set_error]])
-      end
+      ret
     end
 
     # Formats a textarea.  Respects the following options:
@@ -319,7 +307,19 @@ module Forme
       handle_errors_option
 
       Forme.attr_classes(@attr, @opts[:class]) if @opts.has_key?(:class)
-      Forme.attr_classes(@attr, 'error') if @opts[:error]
+
+      if @opts[:error]
+        Forme.attr_classes(@attr, 'error')
+        @attr["aria-invalid"] = "true"
+        if @opts.fetch(:error_handler, true)
+          unless @opts[:error_id]
+            if id = @attr[:id] || @attr['id']
+              error_id = @attr['aria-describedby'] ||= "#{id}_error_message"
+              @opts[:error_id] = error_id
+            end
+          end
+        end
+      end
 
       if data = opts[:data]
         data.each do |k, v|
@@ -462,7 +462,7 @@ module Forme
             text = x
           end
 
-          yield [text, val, val ? cmp.call(val) : cmp.call(text), attr]
+          yield [text, val, !val.nil? ? cmp.call(val) : cmp.call(text), attr]
         end
       end
     end
@@ -538,8 +538,11 @@ module Forme
     end
 
     # Use a span with text instead of an input field.
+    # For hidden inputs, do not show anything
     def _format_input(type)
-      tag(:span, {}, @attr[:value])
+      unless type.to_s == 'hidden'
+        tag(:span, {'class'=>'readonly-text'}, @attr[:value])
+      end
     end
 
     # Disabled radio button inputs.
@@ -560,9 +563,20 @@ module Forme
       ''
     end
 
-    # Use a span with text instead of a text area.
+    # Format the text as separate paragraphs.
     def format_textarea
-      tag(:span, {}, @attr[:value])
+      text = @attr[:value]
+      case text
+      when nil, Forme::Raw
+        # nothing
+      when String
+        text = text.gsub(/\A[\r\n]+|[\r\n]+\z/, '').split(/(?:\r?\n)(?:\r?\n)+/).map do |t|
+          t = Forme.h(t)
+          t.gsub!(/\r?\n/, "<br />")
+          tag(:p, {}, Forme.raw(t))
+        end
+      end
+      tag(:div, {'class'=>'readonly-textarea'}, text)
     end
   end
 end