forme 1.12.0 → 2.2.0

data/lib/forme/rails.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-require 'forme'
+require_relative 'template'
 
 class ActiveSupport::SafeBuffer
   include Forme::Raw
@@ -8,104 +8,60 @@ end
 
 module Forme
   module Rails
-    HIDDEN_TAGS = []
-
-    # Add a hidden tag proc that will be used for all forms created via Forme::Rails::ERB#form.
-    # The block is yielded the Forme::Tag object for the form tag.
-    # The block should return either nil if hidden tag should be added, or a Forme::Tag object (or an array of them),
-    # or a hash with keys specifying the name of the tags and the values specifying the values of the tags .
-    def self.add_hidden_tag(&block)
-      HIDDEN_TAGS << block
-    end
-
-    # Add CSRF token tag by default for POST forms
-    add_hidden_tag do |tag|
-      if (form = tag.form) && (template = form.template) && template.protect_against_forgery? && (tag.attr[:method] || tag.attr['method']).to_s.upcase == 'POST'
-        {template.request_forgery_protection_token=>template.form_authenticity_token}
+    class TemplateForm < ::Forme::Template::Form
+      %w'inputs tag subform'.each do |meth|
+        class_eval(<<-END, __FILE__, __LINE__+1)
+          def #{meth}(*)
+            if block_given?
+              @scope.send(:with_output_buffer){super}
+            else
+              @scope.raw(super)
+            end
+          end
+        END
       end
-    end
-
-    # Subclass used when using Forme/Rails ERB integration,
-    # handling integration with the view template.
-    class Form < ::Forme::Form
-      # The Rails template that created this form.
-      attr_reader :template
 
-      # Set the template object when initializing.
-      def initialize(*)
-        super
-        @template = @opts[:template]
+      %w'button input'.each do |meth|
+        class_eval(<<-END, __FILE__, __LINE__+1)
+          def #{meth}(*)
+            @scope.raw(super)
+          end
+        END
       end
 
-      # Serialize and mark as already escaped the string version of
-      # the input.
       def emit(tag)
-        template.output_buffer << tag.to_s
+        @scope.output_buffer << @scope.raw(tag)
       end
+    end
 
-      # Capture the inputs into a new output buffer, and return
-      # the buffer if not given a block
-      def inputs(*)
+    ERB = Template::Helper.clone
+    module ERB
+      alias _forme form
+      remove_method :form
+
+      def forme(*a, &block)
         if block_given?
-          super
-        else
-          template.send(:with_output_buffer){super}
-        end
-      end
-      
-      # If a block is not given, emit the inputs into the current output
-      # buffer.
-      def _inputs(inputs=[], opts={}) # :nodoc:
-        if block_given? && !opts[:subform]
-          super
+          with_output_buffer{_forme(*a, &block)}
         else
-          emit(super)
+          raw(_forme(*a, &block))
         end
       end
 
-      # Return a string version of the input that is already marked as safe.
-      def input(*)
-        super.to_s
-      end
-
-      # Return a string version of the button that is already marked as safe.
-      def button(*)
-        super.to_s
-      end
-
-      # Use the template's raw method to mark the given string as html safe.
-      def raw_output(s)
-        template.raw(s)
-      end
+      private
 
-      # If a block is given, create a new output buffer and make sure all the
-      # output of the tag goes into that buffer, and return the buffer.
-      # Otherwise, just return a string version of the tag that is already
-      # marked as safe.
-      def tag(type, attr={}, children=[], &block)
-        if block_given?
-          template.send(:with_output_buffer){tag_(type, attr, children, &block)}
-        else
-          _tag(type, attr, children).to_s
+      remove_method :_forme_form_options
+      def _forme_form_options(obj, attr, opts)
+        if protect_against_forgery?
+          opts[:_before_post] = lambda do |form|
+            form.tag(:input, :type=>:hidden, :name=>request_forgery_protection_token, :value=>form_authenticity_token)
+          end
         end
       end
-      
-      def tag_(type, attr={}, children=[]) # :nodoc:
-        tag = _tag(type, attr, children)
-        emit(serialize_open(tag))
-        Array(tag.children).each{|c| emit(c)}
-        yield self if block_given?
-        emit(serialize_close(tag))
-      end
-    end
 
-    module ERB
-      # Create a +Form+ object tied to the current template, and using the standard
-      # Rails hidden tags.
-      def forme(obj=nil, attr={}, opts={}, &block)
-        h = {:template=>self, :hidden_tags=>Forme::Rails::HIDDEN_TAGS}
-        (obj.is_a?(Hash) ? attr = attr.merge(h) : opts = opts.merge(h))
-        Form.form(obj, attr, opts, &block)
+      remove_method :_forme_form_class
+      # The class to use for forms
+      def _forme_form_class
+        TemplateForm
       end
     end
   end

data/lib/forme/raw.rb

@@ -2,12 +2,12 @@
 
 module Forme
   # Empty module for marking objects as "raw", where they will no longer
-  # html escaped by the default serializer.
+  # HTML escaped by the default serializer.
   module Raw
   end
 
   # A String subclass that includes Raw, which will cause the default
-  # serializer to no longer html escape the string.
+  # serializer to no longer HTML escape the string.
   class RawString < ::String
     include Raw
   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,110 @@
+# 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.
+      # Does nothing by default.
+      def _forme_form_options(obj, attr, opts)
+      end
+    end 
+  end
+end

data/lib/forme/transformers/error_handler.rb

@@ -49,17 +49,17 @@ module Forme
     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
+      if tag.is_a?(Array) && tag.first.is_a?(Tag) && 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"
 
-      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))
+        tag.insert(1, error_tag(input))
+      else
+        super 
+      end
     end
   end
 end

data/lib/forme/transformers/formatter.rb

@@ -220,7 +220,7 @@ module Forme
     end
 
     def _format_set(type, tag_attrs={})
-      raise Error, "can't have radioset with no options" unless @opts[:optgroups] || @opts[:options]
+      raise Error, "can't have radioset or checkboxset with no options" unless @opts[:optgroups] || @opts[:options]
       key = @opts[:key]
       name = @opts[:name]
       id = @opts[:id]
@@ -312,7 +312,9 @@ module Forme
         Forme.attr_classes(@attr, 'error')
         @attr["aria-invalid"] = "true"
         if @opts.fetch(:error_handler, true)
-          unless @opts[:error_id]
+          if @opts[:error_id]
+            @attr['aria-describedby'] ||= @opts[:error_id]
+          else
             if id = @attr[:id] || @attr['id']
               error_id = @attr['aria-describedby'] ||= "#{id}_error_message"
               @opts[:error_id] = error_id
@@ -397,9 +399,7 @@ module Forme
 
     def set_error_from_namespaced_errors(namespaces, errors, key)
       namespaces.each do |ns|
-        e = errors[ns] || errors[ns.to_s]
-        return unless e
-        errors = e
+        return unless errors = errors[ns] || errors[ns.to_s]
       end
 
       @opts[:error] = errors.fetch(key){errors.fetch(key.to_s){return}}
@@ -432,38 +432,36 @@ module Forme
     # Iterate over the given options, yielding the option text, value, whether it is selected, and any attributes.
     # The block should return an appropriate tag object.
     def process_select_options(os)
-      if os
-        vm = @opts[:value_method]
-        tm = @opts[:text_method]
-        sel = @opts[:selected] || @attr.delete(:value)
-
-        if @opts[:multiple]
-          sel = Array(sel)
-          cmp = lambda{|v| sel.include?(v)}
-        else
-          cmp = lambda{|v| v == sel}
-        end
+      vm = @opts[:value_method]
+      tm = @opts[:text_method]
+      sel = @opts[:selected] || @attr.delete(:value)
 
-        os.map do |x|
-          attr = {}
-          if tm
-            text = x.send(tm)
-            val = x.send(vm) if vm
-          elsif x.is_a?(Array)
-            text = x.first
-            val = x.last
-
-            if val.is_a?(Hash)
-              value = val[:value]
-              attr.merge!(val)
-              val = value
-            end
-          else
-            text = x
-          end
+      if @opts[:multiple]
+        sel = Array(sel)
+        cmp = lambda{|v| sel.include?(v)}
+      else
+        cmp = lambda{|v| v == sel}
+      end
 
-          yield [text, val, !val.nil? ? cmp.call(val) : cmp.call(text), attr]
+      os.map do |x|
+        attr = {}
+        if tm
+          text = x.send(tm)
+          val = x.send(vm) if vm
+        elsif x.is_a?(Array)
+          text = x.first
+          val = x.last
+
+          if val.is_a?(Hash)
+            value = val[:value]
+            attr.merge!(val)
+            val = value
+          end
+        else
+          text = x
         end
+
+        yield [text, val, !val.nil? ? cmp.call(val) : cmp.call(text), attr]
       end
     end
 

data/lib/forme/transformers/helper.rb

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

data/lib/forme/transformers/inputs_wrapper.rb

@@ -15,7 +15,7 @@ module Forme
       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
@@ -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/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 = 12
+  MINOR = 2
 
   # The patch version of Forme, updated only for bug fixes from the last
   # feature release.

data/lib/forme.rb

@@ -162,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,57 @@
+# 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
+      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
 
-          apply_csrf = options[:csrf]
+        # Add the csrf and hidden tags options if needed.
+        def _forme_form_options(obj, attr, opts)
+          super
+
+          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,32 +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[:csrf] = [csrf_field, token]
-            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_form_options(options)
-          _forme_form_class.form(obj, attr, opts, &block)
-        end
-
-        private
-
-        # The class to use for forms
-        def _forme_form_class
-          ::Forme::ERB::Form
-        end
-
-        # The options to use for forms.  Any changes should mutate this hash to set options.
-        def _forme_form_options(options)
-          options
         end
       end
     end