forme 1.12.0 → 2.0.0

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/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 = 0
 
   # 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,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
 
-          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

data/lib/roda/plugins/forme_set.rb

@@ -1,7 +1,7 @@
 # frozen-string-literal: true
 
 require 'rack/utils'
-require 'forme/erb_form'
+require_relative '../../forme/template'
 
 class Roda
   module RodaPlugins
@@ -34,74 +34,6 @@ class Roda
         :missing_namespace=>"no content in expected namespace"
       }.freeze
 
-      # Forme::Form subclass that adds hidden fields with metadata that can be used
-      # to automatically process form submissions.
-      class Form < ::Forme::ERB::Form
-        def initialize(obj, opts=nil)
-          super
-          @forme_namespaces = @opts[:namespace]
-        end
-
-        # Try adding hidden fields to all forms
-        def form(*)
-          if block_given?
-            super do |f|
-              yield f
-              hmac_hidden_fields
-            end
-          else
-            t = super
-            if tags = hmac_hidden_fields
-              tags.each{|tag| t << tag}
-            end
-            t
-          end
-        end
-
-        private
-
-        # Add hidden fields with metadata, if the form has an object associated that
-        # supports the forme_inputs method, and it includes inputs.
-        def hmac_hidden_fields
-          if (obj = @opts[:obj]) && obj.respond_to?(:forme_inputs) && (forme_inputs = obj.forme_inputs)
-            columns = []
-            valid_values = {}
-
-            forme_inputs.each do |field, input|
-              next unless col = obj.send(:forme_column_for_input, input)
-              col = col.to_s
-              columns << col
-
-              next unless validation = obj.send(:forme_validation_for_input, field, input)
-              validation[0] = validation[0].to_s
-              has_nil = false
-              validation[1] = validation[1].map do |v|
-                has_nil ||= v.nil?
-                v.to_s
-              end
-              validation[1] << nil if has_nil
-              valid_values[col] = validation
-            end
-
-            return if columns.empty?
-
-            data = {}
-            data['columns'] = columns
-            data['namespaces'] = @forme_namespaces
-            data['csrf'] = @opts[:csrf]
-            data['valid_values'] = valid_values unless valid_values.empty?
-            data['form_version'] = @opts[:form_version] if @opts[:form_version]
-
-            data = data.to_json
-            tags = []
-            tags << tag(:input, :type=>:hidden, :name=>:_forme_set_data, :value=>data)
-            tags << tag(:input, :type=>:hidden, :name=>:_forme_set_data_hmac, :value=>OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA512.new, @opts[:roda].class.opts[:forme_set_hmac_secret], data))
-            tags.each{|tag| emit(tag)}
-            tags
-          end
-        end
-      end
-
       module InstanceMethods
         # Return hash based on submitted parameters, with :values key
         # being submitted values for the object, and :validations key
@@ -151,15 +83,46 @@ class Roda
           raise Error, ERROR_MESSAGES[type]
         end
 
-        # Use form class that adds hidden fields for metadata.
-        def _forme_form_class
-          Form
-        end
-
         # Include a reference to the current scope to the form.  This reference is needed
         # to correctly construct the HMAC.
-        def _forme_form_options(options)
-          options.merge!(:roda=>self)
+        def _forme_form_options(obj, attr, opts)
+          super
+
+          opts[:_after] = lambda do |form|
+            if (obj = form.opts[:obj]) && obj.respond_to?(:forme_inputs) && (forme_inputs = obj.forme_inputs)
+              columns = []
+              valid_values = {}
+
+              forme_inputs.each do |field, input|
+                next unless col = obj.send(:forme_column_for_input, input)
+                col = col.to_s
+                columns << col
+
+                next unless validation = obj.send(:forme_validation_for_input, field, input)
+                validation[0] = validation[0].to_s
+                has_nil = false
+                validation[1] = validation[1].map do |v|
+                  has_nil ||= v.nil?
+                  v.to_s
+                end
+                validation[1] << nil if has_nil
+                valid_values[col] = validation
+              end
+
+              return if columns.empty?
+
+              data = {}
+              data['columns'] = columns
+              data['namespaces'] = form.opts[:namespace]
+              data['csrf'] = form.opts[:csrf]
+              data['valid_values'] = valid_values unless valid_values.empty?
+              data['form_version'] = form.opts[:form_version] if form.opts[:form_version]
+
+              data = data.to_json
+              form.tag(:input, :type=>:hidden, :name=>:_forme_set_data, :value=>data)
+              form.tag(:input, :type=>:hidden, :name=>:_forme_set_data_hmac, :value=>OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA512.new, self.class.opts[:forme_set_hmac_secret], data))
+            end
+          end
         end
 
         # Internals of forme_parse_hmac and forme_set_hmac.

data/lib/sequel/plugins/forme.rb

@@ -1,7 +1,6 @@
 # frozen-string-literal: true
 
-require 'forme'
-require 'thread'
+require_relative '../../forme'
 
 module Sequel # :nodoc:
   module Plugins # :nodoc:
@@ -37,7 +36,8 @@ module Sequel # :nodoc:
         # of the association for the form's +obj+. Inside the block, calls to
         # the +input+ and +inputs+ methods for the receiver treat the associated
         # object as the recevier's +obj+, using name and id attributes that work
-        # with the Sequel +nested_attributes+ plugin.
+        # with the Sequel +nested_attributes+ plugin. Returns the HTML generated by
+        # the subform.
         #
         # The following options are currently supported:
         # :inputs :: Automatically call +inputs+ with the given values.  Using
@@ -59,45 +59,47 @@ module Sequel # :nodoc:
         # :skip_primary_key :: Skip adding a hidden primary key field for existing
         #                      objects.
         def subform(association, opts={}, &block)
-          nested_obj = opts.has_key?(:obj) ? opts[:obj] : obj.send(association)
-          ref = obj.class.association_reflection(association)
-          multiple = ref.returns_array?
-          grid = opts[:grid]
-          ns = "#{association}_attributes"
-
-          contents = proc do
-            send(multiple ? :each_obj : :with_obj, nested_obj, ns) do |no, i|
-              emit(input(ref.associated_class.primary_key, :type=>:hidden, :label=>nil, :wrapper=>nil)) unless no.new? || opts[:skip_primary_key]
-              options = opts.dup
-              if grid
-                options.delete(:legend)
-              else
-                if options.has_key?(:legend)
-                  if options[:legend].respond_to?(:call)
-                    options[:legend] = multiple ? options[:legend].call(no, i) : options[:legend].call(no)
-                  end
+          content_added do
+            nested_obj = opts.has_key?(:obj) ? opts[:obj] : obj.send(association)
+            ref = obj.class.association_reflection(association)
+            multiple = ref.returns_array?
+            grid = opts[:grid]
+            ns = "#{association}_attributes"
+
+            contents = proc do
+              send(multiple ? :each_obj : :with_obj, nested_obj, ns) do |no, i|
+                input(ref.associated_class.primary_key, :type=>:hidden, :label=>nil, :wrapper=>nil) unless no.new? || opts[:skip_primary_key]
+                options = opts.dup
+                if grid
+                  options.delete(:legend)
                 else
-                  if multiple
-                    options[:legend] = humanize("#{obj.model.send(:singularize, association)} ##{i+1}")
+                  if options.has_key?(:legend)
+                    if options[:legend].respond_to?(:call)
+                      options[:legend] = multiple ? options[:legend].call(no, i) : options[:legend].call(no)
+                    end
                   else
-                    options[:legend] = humanize(association)
+                    if multiple
+                      options[:legend] = humanize("#{obj.model.send(:singularize, association)} ##{i+1}")
+                    else
+                      options[:legend] = humanize(association)
+                    end
                   end
                 end
+                options[:subform] = true
+
+                inputs(options[:inputs]||[], options, &block)
               end
-              options[:subform] = true
-              _inputs(options[:inputs]||[], options, &block)
+            end
+            
+            if grid
+              labels = opts.fetch(:labels){opts[:inputs].map{|l, *| humanize(l)} if opts[:inputs]}
+              legend = opts.fetch(:legend){humanize(association)}
+              inputs_opts = opts[:inputs_opts] || {}
+              inputs(inputs_opts.merge(:inputs_wrapper=>:table, :nested_inputs_wrapper=>:tr, :wrapper=>:td, :labeler=>nil, :labels=>labels, :legend=>legend), &contents)
+            else
+              contents.call
             end
           end
-          
-          if grid
-            labels = opts.fetch(:labels){opts[:inputs].map{|l, *| humanize(l)} if opts[:inputs]}
-            legend = opts.fetch(:legend){humanize(association)}
-            inputs_opts = opts[:inputs_opts] || {}
-            inputs(inputs_opts.merge(:inputs_wrapper=>:table, :nested_inputs_wrapper=>:tr, :wrapper=>:td, :labeler=>nil, :labels=>labels, :legend=>legend), &contents)
-          else
-            contents.call
-          end
-          nil
         end
       end
 
@@ -452,21 +454,6 @@ module Sequel # :nodoc:
         end
       end
 
-      # Helper module used for Sequel forms using ERB template integration.  Necessary for
-      # proper subform handling when using such forms with partials.
-      module ERBSequelForm
-        # Capture the inside of the inputs, injecting it into the template
-        # if a block is given, or returning it as a string if not.
-        def subform(*, &block)
-          if block
-            capture(block){super}
-          else
-            capture{super}
-          end
-        end
-      end
-      SinatraSequelForm = ERBSequelForm
-
       class Form < ::Forme::Form
         include SequelForm
       end
@@ -486,7 +473,6 @@ module Sequel # :nodoc:
           unless klass = MUTEX.synchronize{FORM_CLASSES[base]}
             klass = Class.new(base)
             klass.send(:include, SequelForm)
-            klass.send(:include, ERBSequelForm) if defined?(::Forme::ERB::Form) && base == ::Forme::ERB::Form
             MUTEX.synchronize{FORM_CLASSES[base] = klass}
           end
           klass

data/lib/sequel/plugins/forme_i18n.rb

@@ -1,5 +1,7 @@
+# frozen-string-literal: true
+
 require 'i18n'
-require 'sequel/plugins/forme'
+require_relative 'forme'
 
 module Sequel # :nodoc:
   module Plugins # :nodoc:

data/spec/all.rb

@@ -1,2 +1,2 @@
 $: << 'lib'
-Dir['./spec/*_spec.rb'].each{|f| require f}
+Dir.new(File.dirname(__FILE__)).each{|f| require_relative f if f.end_with?('_spec.rb')}