forme 1.12.0 → 2.2.0

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,50 @@ 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"
+          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|
-              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
+              input(ref.associated_class.primary_key, :type=>:hidden, :label=>nil, :wrapper=>nil) unless no.new? || opts[:skip_primary_key]
+            end
+
+            contents = proc do
+              send(multiple ? :each_obj : :with_obj, nested_obj, ns) do |no, i|
+                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
 
@@ -358,9 +363,10 @@ module Sequel # :nodoc:
             opts[:as] = (sch[:allow_null] || opts[:required] == false) ? :select : :checkbox
           end
 
+          v = opts.has_key?(:value) ? opts[:value] : obj.send(field)
+
           case opts[:as]
           when :radio
-            v = opts.has_key?(:value) ? opts[:value] : obj.send(field)
             true_value = opts[:true_value]||'t'
             false_value = opts[:false_value]||'f'
             opts[:options] = [[opts[:true_label]||'Yes', {:value=>true_value, :key_id=>'yes'}], [opts[:false_label]||'No', {:value=>false_value, :key_id=>'no'}]]
@@ -369,13 +375,12 @@ module Sequel # :nodoc:
             end
             _input(:radioset, opts)
           when :select
-            v = opts[:value] || obj.send(field)
             opts[:value] = (v ? 't' : 'f') unless v.nil?
             opts[:add_blank] = true unless opts.has_key?(:add_blank)
             opts[:options] = [[opts[:true_label]||'True', opts[:true_value]||'t'], [opts[:false_label]||'False', opts[:false_value]||'f']]
             _input(:select, opts)
           else
-            opts[:checked] = obj.send(field)
+            opts[:checked] = v
             opts[:value] = 't'
             _input(:checkbox, opts)
           end
@@ -419,9 +424,11 @@ module Sequel # :nodoc:
           end
         end
 
-        # Use number inputs for integers.
+        # Use inputmode and pattern attributes for integers.
         def input_integer(sch)
-          standard_input(:number)
+          opts[:attr][:inputmode] ||= 'numeric'
+          opts[:attr][:pattern] ||= '-?[0-9]*'
+          standard_input(:text)
         end
 
         # Use date inputs for dates.
@@ -452,21 +459,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 +478,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/lib/sequel/plugins/forme_set.rb

@@ -105,10 +105,8 @@ module Sequel # :nodoc:
           opts = input.opts
           return if SKIP_FORMATTERS.include?(opts.fetch(:formatter){input.form_opts[:formatter]})
 
-          if attr = opts[:attr]
-            name = attr[:name] || attr['name']
-          end
-          return unless name ||= opts[:name] || opts[:key]
+          attr = opts[:attr] || {}
+          return unless name ||= attr[:name] || attr['name'] || opts[:name] || opts[:key]
 
           # Pull out last component of the name if there is one
           column = name.to_s.chomp('[]')

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')}