forme 1.9.0 → 2.0.0

data/lib/forme/sinatra.rb

@@ -1,6 +1,10 @@
 # frozen-string-literal: true
 
-require 'forme/erb'
+if RUBY_VERSION >= '2'
+  warn('forme/sinatra and Forme::Sinatra::ERB are deprecated and will be removed in a future version, switch to forme/erb and Forme::ERB::Helper', :uplevel=>1)
+end
+
+require_relative 'erb'
 
 module Forme
   # For backwards compatibility only.  New code should
@@ -11,7 +15,7 @@ module Forme
   module Sinatra
     ERB = Forme::ERB::Helper
     Erubis = ERB
-    Form = Forme::ERB::Form
+    Form = Forme::Template::Form
     HIDDEN_TAGS = Forme::ERB::HIDDEN_TAGS
   end
 end

data/lib/forme/tag.rb

@@ -1,8 +1,8 @@
 # frozen-string-literal: true
 
 module Forme
-  # Low level abstract tag form, where each instance represents a
-  # html tag with attributes and children.
+  # Low level abstract tag form, where each instance represents an
+  # HTML tag with attributes and children.
   class Tag
     # The +Form+ object related to the receiver.
     attr_reader :form
@@ -23,15 +23,6 @@ module Forme
       @children = parse_children(children)
     end
 
-    # Adds a child to the array of receiver's children.
-    def <<(child)
-      if children
-        children << child
-      else
-        @children = [child]
-      end
-    end
-
     # Create a new +Tag+ instance with the given arguments and block
     # related to the receiver's +form+.
     def tag(*a, &block)
@@ -40,7 +31,7 @@ module Forme
 
     # Return a string containing the serialized content of the receiver.
     def to_s
-      form.raw_output(Forme.transform(:serializer, @opts, @form.opts, self))
+      Forme.transform(:serializer, @opts, @form.opts, self)
     end
 
     private

data/lib/forme/template.rb

@@ -0,0 +1,118 @@
+# frozen-string-literal: true
+
+require_relative '../forme'
+
+module Forme
+  module Template
+    class Form
+      def initialize(form, scope)
+        @form = form
+        @scope = scope
+      end
+
+      # Delegate calls by default to the wrapped form
+      def method_missing(*a, &block)
+        @form.public_send(*a, &block)
+      end
+
+      # If a block is given to inputs, tag, or subform, 
+      # emit the already generated HTML for the form before yielding
+      # to the block, and after returning, emit any HTML generated
+      # after returning from the block.
+      %w'inputs tag subform'.each do |meth|
+        class_eval(<<-END, __FILE__, __LINE__+1)
+          def #{meth}(*a, &block)
+            return @form.#{meth}(*a) unless block
+
+            buffer = @form.to_s
+            offset = buffer.length
+            @form.#{meth}(*a) do
+              emit(buffer[offset, buffer.length])
+              yield self
+              offset = buffer.length
+            end
+            emit(buffer[offset, buffer.length])
+
+            nil
+          end
+        END
+      end
+
+      # Serialize the tag and inject it into the output.
+      def emit(tag)
+        return unless output = output()
+        output << tag
+      end
+
+      private
+
+      def output
+        @scope.instance_variable_get(:@_out_buf)
+      end
+    end
+
+    # This is the module used to add the Forme integration
+    # to ERB.
+    module Helper 
+      # Create a +Form+ object tied to the current output buffer,
+      # using the standard ERB hidden tags.
+      def form(obj=nil, attr={}, opts={}, &block)
+        if obj.is_a?(Hash)
+          attribs = obj
+          options = attr = attr.dup
+        else
+          attribs = attr
+          options = opts = opts.dup
+        end
+
+        _forme_form_options(obj, attribs, options)
+        _forme_form(obj, attr, opts, &block)
+      end
+
+      private
+
+      def _forme_form(obj, attr, opts, &block)
+        if block_given?
+          erb_form = buffer = offset = nil
+          block = proc do
+            wrapped_form = erb_form.instance_variable_get(:@form)
+            buffer = wrapped_form.to_s
+            offset = buffer.length
+            erb_form.emit(buffer[0, buffer.length])
+            yield erb_form
+            offset = buffer.length
+          end
+
+          f, attr, block = _forme_wrapped_form_class.form_args(obj, attr, opts, &block)
+          erb_form = _forme_form_class.new(f, self)
+          erb_form.form(attr, &block)
+          erb_form.emit(buffer[offset, buffer.length])
+        else
+          _forme_wrapped_form_class.form(obj, attr, opts, &block)
+        end
+      end
+
+      def _forme_wrapped_form_class
+        ::Forme::Form
+      end
+
+      # The class to use for forms
+      def _forme_form_class
+        Form
+      end
+
+      # The options to use for forms.  Any changes should mutate this hash to set options.
+      def _forme_form_options(obj, attr, opts)
+        if hidden_tags = _forme_form_hidden_tags
+          opts[:hidden_tags] ||= []
+          opts[:hidden_tags] += hidden_tags
+        end
+        opts[:hidden_tags_uplevel] = 1
+      end
+
+      def _forme_form_hidden_tags
+        nil
+      end
+    end 
+  end
+end

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
@@ -221,23 +224,22 @@ 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|
+      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)
+        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
@@ -255,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
-
-    def set_label
-      form._tag(:span, {:class=>:label}, @opts[:set_label])
-    end
+      @opts[:first_input] = first_input
+      @opts[:last_input] = last_input
 
-    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:
@@ -321,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|
@@ -540,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, {'class'=>'readonly-text'}, @attr[:value])
+      unless type.to_s == 'hidden'
+        tag(:span, {'class'=>'readonly-text'}, @attr[:value])
+      end
     end
 
     # Disabled radio button inputs.

data/lib/forme/transformers/helper.rb

@@ -16,4 +16,3 @@ module Forme
     end
   end
 end
-

data/lib/forme/transformers/inputs_wrapper.rb

@@ -10,16 +10,16 @@ module Forme
     # Wrap the inputs in a <fieldset>.  If the :legend
     # option is given, add a <legend> tag as the first
     # child of the fieldset.
-    def call(form, opts)
+    def call(form, opts, &block)
       attr = opts[:attr] ? opts[:attr].dup : {}
       Forme.attr_classes(attr, 'inputs')
       if legend = opts[:legend]
         form.tag(:fieldset, attr) do
-          form.emit(form.tag(:legend, opts[:legend_attr], legend))
+          form.tag(:legend, opts[:legend_attr], legend)
           yield
         end
       else
-        form.tag(:fieldset, attr, &Proc.new)
+        form.tag(:fieldset, attr, &block)
       end
     end
   end
@@ -32,7 +32,7 @@ module Forme
 
     # Wrap the inputs in a <fieldset> and a <ol> tag.
     def call(form, opts)
-      super(form, opts){form.tag_(:ol){yield}}
+      super(form, opts){form.tag(:ol){yield}}
     end
   end
 
@@ -83,12 +83,12 @@ module Forme
       attr = opts[:attr] ? opts[:attr].dup : {}
       form.tag(:table, attr) do
         if legend = opts[:legend]
-          form.emit(form.tag(:caption, opts[:legend_attr], legend))
+          form.tag(:caption, opts[:legend_attr], legend)
         end
 
         if (labels = opts[:labels]) && !labels.empty?
           form.tag(:thead) do
-            form.emit(form.tag(:tr, {}, labels.map{|l| form._tag(:th, {}, l)}))
+            form.tag(:tr, {}, labels.map{|l| form._tag(:th, {}, l)})
           end
         end
 

data/lib/forme/transformers/labeler.rb

@@ -77,4 +77,23 @@ module Forme
       t
     end
   end
+
+  class Labeler::Span
+    Forme.register_transformer(:labeler, :span, new)
+
+    def call(tag, input)
+      label_attr = input.opts[:label_attr]
+      label_attr = label_attr ? label_attr.dup : {}
+      Forme.attr_classes(label_attr, "label")
+      [input.tag(:span, label_attr, input.opts[:label]), tag]
+    end
+  end
+
+  class Labeler::Legend
+    Forme.register_transformer(:labeler, :legend, new)
+
+    def call(tag, input)
+      [input.tag(:legend, input.opts[:label_attr], input.opts[:label]), tag]
+    end
+  end
 end

data/lib/forme/transformers/wrapper.rb

@@ -23,7 +23,7 @@ module Forme
       input.tag(@type, input.opts[:wrapper_attr], super)
     end
 
-    [:li, :p, :div, :span, :td].each do |x|
+    [:li, :p, :div, :span, :td, :fieldset].each do |x|
       Forme.register_transformer(:wrapper, x, new(x))
     end
   end

data/lib/forme/version.rb

@@ -3,10 +3,10 @@
 module Forme
   # The major version of Forme, updated only for major changes that are
   # likely to require modification to apps using Forme.
-  MAJOR = 1
+  MAJOR = 2
 
   # The minor version of Forme, updated for new feature releases of Forme.
-  MINOR = 9
+  MINOR = 0
 
   # The patch version of Forme, updated only for bug fixes from the last
   # feature release.

data/lib/forme.rb

@@ -10,6 +10,7 @@ module Forme
 
   begin
     require 'cgi/escape'
+  # :nocov:
     unless CGI.respond_to?(:escapeHTML) # work around for JRuby 9.1
       CGI = Object.new
       CGI.extend(defined?(::CGI::Escape) ? ::CGI::Escape : ::CGI::Util)
@@ -32,6 +33,7 @@ module Forme
       end
     end
   end
+  # :nocov:
 
   @default_add_blank_prompt = nil
   @default_config = :default
@@ -160,5 +162,16 @@ module Forme
   end
 end
 
-%w'form input tag raw version'.each{|f| require File.expand_path("../forme/#{f}", __FILE__)}
-%w'error_handler formatter helper inputs_wrapper labeler serializer wrapper'.each{|f| require File.expand_path("../forme/transformers/#{f}", __FILE__)}
+require_relative 'forme/form'
+require_relative 'forme/input'
+require_relative 'forme/tag'
+require_relative 'forme/raw'
+require_relative 'forme/version'
+
+require_relative 'forme/transformers/error_handler'
+require_relative 'forme/transformers/formatter'
+require_relative 'forme/transformers/helper'
+require_relative 'forme/transformers/inputs_wrapper'
+require_relative 'forme/transformers/labeler'
+require_relative 'forme/transformers/serializer'
+require_relative 'forme/transformers/wrapper'

data/lib/roda/plugins/forme.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-require 'forme/erb'
+require_relative '../../forme/erb'
 
 class Roda
   module RodaPlugins

data/lib/roda/plugins/forme_erubi_capture.rb

@@ -0,0 +1,62 @@
+# frozen-string-literal: true
+
+require_relative '../../forme/template'
+
+class Roda
+  module RodaPlugins
+    module FormeErubiCapture
+      def self.load_dependencies(app)
+        app.plugin :forme_route_csrf
+        app.plugin :capture_erb
+        app.plugin :inject_erb
+      end
+
+      class Form < ::Forme::Template::Form
+        %w'inputs tag subform'.each do |meth|
+          class_eval(<<-END, __FILE__, __LINE__+1)
+            def #{meth}(*)
+              if block_given?
+                @scope.capture_erb do
+                  super
+                  @scope.instance_variable_get(@scope.render_opts[:template_opts][:outvar])
+                end
+              else
+                super
+              end
+            end
+          END
+        end
+        
+        def emit(tag)
+          @scope.inject_erb(tag)
+        end
+      end
+
+      module InstanceMethods
+        def form(*)
+          if block_given?
+            capture_erb do
+              super
+              instance_variable_get(render_opts[:template_opts][:outvar])
+            end
+          else
+            super
+          end
+        end
+
+        private
+
+        def _forme_form_class
+          Form
+        end
+
+        def _forme_form_options(obj, attr, opts)
+          super
+          opts[:hidden_tags_uplevel] = 2
+        end
+      end
+    end
+
+    register_plugin(:forme_erubi_capture, FormeErubiCapture)
+  end
+end

data/lib/roda/plugins/forme_route_csrf.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-require 'forme/erb_form'
+require_relative '../../forme/template'
 
 class Roda
   module RodaPlugins
@@ -13,21 +13,18 @@ class Roda
       end
 
       module InstanceMethods
-        # Create a +Form+ object tied to the current output buffer,
-        # using the standard ERB hidden tags.
-        def form(obj=nil, attr={}, opts={}, &block)
-          if obj.is_a?(Hash)
-            attribs = obj
-            options = attr = attr.dup
-          else
-            attribs = attr
-            options = opts = opts.dup
-          end
+        include ::Forme::Template::Helper
+
+        private
+
+        # Add the csrf and hidden tags options if needed.
+        def _forme_form_options(obj, attr, opts)
+          super
 
-          apply_csrf = options[:csrf]
+          apply_csrf = opts[:csrf]
 
           if apply_csrf || apply_csrf.nil?
-            unless method = attribs[:method] || attribs['method']
+            unless method = attr[:method] || attr['method']
               if obj && !obj.is_a?(Hash) && obj.respond_to?(:forme_default_request_method)
                 method = obj.forme_default_request_method
               end
@@ -39,18 +36,17 @@ class Roda
           end
 
           if apply_csrf
-            token = if options.fetch(:use_request_specific_token){use_request_specific_csrf_tokens?}
-              csrf_token(csrf_path(attribs[:action]), method)
+            token = if opts.fetch(:use_request_specific_token){use_request_specific_csrf_tokens?}
+              csrf_token(csrf_path(attr[:action]), method)
             else
               csrf_token
             end
 
-            options[:hidden_tags] ||= []
-            options[:hidden_tags] += [{csrf_field=>token}]
+            opts[:csrf] = [csrf_field, token]
+            opts[:_before] = lambda do |form|
+              form.tag(:input, :type=>:hidden, :name=>csrf_field, :value=>token)
+            end
           end
-
-          options[:output] = @_out_buf if block
-          ::Forme::ERB::Form.form(obj, attr, opts, &block)
         end
       end
     end