forme 1.11.0 → 2.1.0

data/Rakefile

@@ -50,7 +50,7 @@ end
 
 desc "Run specs"
 task :spec do
-  sh "#{FileUtils::RUBY} spec/all.rb"
+  sh "#{FileUtils::RUBY} #{'-w' if RUBY_VERSION >= '3'} spec/all.rb"
 end
 task :default => :spec
 
@@ -60,12 +60,6 @@ task :spec_cov do
   sh "#{FileUtils::RUBY} spec/all.rb"
 end
 
-desc "Run specs with -w, some warnings filtered"
-task :spec_w do
-  ENV['WARNING'] = '1'
-  sh "#{FileUtils::RUBY} -w spec/all.rb"
-end
-
 ### Other
 
 desc "Print #{NAME} version"

data/lib/forme/bs3.rb

@@ -80,12 +80,26 @@ module Forme
       copy_options_to_attributes(ATTRIBUTE_OPTIONS)
       copy_boolean_options_to_attributes(ATTRIBUTE_BOOLEAN_OPTIONS)
       handle_key_option
+      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|
+          k = k.to_s.tr("_", "-") if k.is_a?(Symbol) && input.opts[:dasherize_data]
           sym = :"data-#{k}"
           @attr[sym] = v unless @attr.has_key?(sym)
         end
@@ -210,7 +224,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
@@ -230,11 +244,11 @@ module Forme
       attr = opts[:attr] ? opts[:attr].dup : { :class=>'table table-bordered'}
       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.emit(form.tag(:tr, {}, labels.map{|l| form._tag(:th, {}, l)}))
+          form.tag(:tr, {}, labels.map{|l| form._tag(:th, {}, l)})
         end
 
         yield

data/lib/forme/erb.rb

@@ -1,36 +1,24 @@
 # frozen-string-literal: true
 
-require 'forme/erb_form'
+require_relative 'template'
 
 module Forme
   module ERB 
-    HIDDEN_TAGS = []
+    # This is the module used to add the Forme integration to ERB templates, with optional support for
+    # rack_csrf for CSRF handling.
+    module Helper 
+      include Template::Helper
 
-    # Add a hidden tag proc that will be used for all forms created via Forme::ERB::Helper#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
+      private
 
-    # Add CSRF token tag by default for POST forms
-    add_hidden_tag do |tag|
-      if defined?(::Rack::Csrf) && (form = tag.form) && (env = form.opts[:env]) && env['rack.session'] && (tag.attr[:method] || tag.attr['method']).to_s.upcase == 'POST'
-        {::Rack::Csrf.field=>::Rack::Csrf.token(env)}
-      end
-    end
+      def _forme_form_options(obj, attr, opts)
+        super
 
-    # 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)
-        h = {:hidden_tags=>Forme::ERB::HIDDEN_TAGS, :env=>env}
-        h[:output] = @_out_buf if block
-        (obj.is_a?(Hash) ? attr = attr.merge(h) : opts = opts.merge(h))
-        Form.form(obj, attr, opts, &block)
+        if defined?(::Rack::Csrf) && env['rack.session']
+          opts[:_before_post] = lambda do |form|
+            form.tag(:input, :type=>:hidden, :name=>::Rack::Csrf.field, :value=>::Rack::Csrf.token(env))
+          end
+        end
       end
     end 
   end

data/lib/forme/form.rb

@@ -2,9 +2,8 @@
 
 module Forme
   # The +Form+ class is the main entry point to the library.  
-  # Using the +form+, +input+, +tag+, and +inputs+ methods, one can easily build 
-  # an abstract syntax tree of +Tag+ and +Input+ instances, which can be serialized
-  # to a string using +to_s+.
+  # Using the +form+, +input+, +tag+, and +inputs+ methods, one can return HTML
+  # form tag string (or fragments of an HTML form tag).
   class Form
     # A hash of options for the form.
     attr_reader :opts
@@ -13,13 +12,17 @@ module Forme
     # input type keys and values that are hashes of input options.
     attr_reader :input_defaults
 
-    # The hidden tags to automatically add to the form.
-    attr_reader :hidden_tags
+    # The attributes used for the form tag for this form.
+    attr_reader :form_tag_attributes
 
     # The +serializer+ determines how +Tag+ objects are transformed into strings.
     # Must respond to +call+ or be a registered symbol.
     attr_reader :serializer
 
+    # The contents of the form as a string.  This should not be mutated by
+    # external code.
+    attr_reader :to_s
+
     # Use appropriate Form subclass for object based on the current class, if the
     # object responds to +forme_form_class+.
     def self.new(obj=nil, opts={})
@@ -30,23 +33,9 @@ module Forme
       end
     end
 
-    # Create a +Form+ instance and yield it to the block,
-    # injecting the opening form tag before yielding and
-    # the closing form tag after yielding.
-    #
-    # Argument Handling:
-    # No args :: Creates a +Form+ object with no options and not associated
-    #            to an +obj+, and with no attributes in the opening tag.
-    # 1 hash arg :: Treated as opening form tag attributes, creating a
-    #               +Form+ object with no options.
-    # 1 non-hash arg :: Treated as the +Form+'s +obj+, with empty options
-    #                   and no attributes in the opening tag.
-    # 2 hash args :: First hash is opening attributes, second hash is +Form+
-    #                options.
-    # 1 non-hash arg, 1-2 hash args :: First argument is +Form+'s obj, second is
-    #                                  opening attributes, third if provided is
-    #                                  +Form+'s options.
-    def self.form(obj=nil, attr={}, opts={}, &block)
+    # Parse the args given to #form and return Form instance, form tag attributes,
+    # and block for form.
+    def self.form_args(obj, attr, opts, &block)
       f = if obj.is_a?(Hash)
         raise Error, "Can't provide 3 hash arguments to form" unless opts.empty?
         opts = attr
@@ -60,12 +49,32 @@ module Forme
       button = opts[:button]
       if ins || button
         block = proc do |form|
-          form._inputs(ins, opts) if ins
+          form.inputs(ins, opts) if ins
           yield form if block_given?
-          form.emit(form.button(button)) if button
+          form.button(button) if button
         end
       end
 
+      [f, attr, block]
+    end
+
+    # Create a +Form+ instance and yield it to the block.  Returns an HTML string
+    # for the form tag.
+    #
+    # Argument Handling:
+    # No args :: Creates a +Form+ object with no options and not associated
+    #            to an +obj+, and with no attributes in the opening tag.
+    # 1 hash arg :: Treated as opening form tag attributes, creating a
+    #               +Form+ object with no options.
+    # 1 non-hash arg :: Treated as the +Form+'s +obj+, with empty options
+    #                   and no attributes in the opening tag.
+    # 2 hash args :: First hash is opening attributes, second hash is +Form+
+    #                options.
+    # 1 non-hash arg, 1-2 hash args :: First argument is +Form+'s obj, second is
+    #                                  opening attributes, third if provided is
+    #                                  +Form+'s options.
+    def self.form(obj=nil, attr={}, opts={}, &block)
+      f, attr, block = form_args(obj, attr, opts, &block)
       f.form(attr, &block)
     end
 
@@ -97,27 +106,33 @@ module Forme
 
       @serializer = @opts[:serializer]
       @input_defaults = @opts[:input_defaults] || {}
-      @hidden_tags = @opts[:hidden_tags]
-      @nesting = []
+      @to_s = String.new
     end
 
-    # Create a form tag with the given attributes.
-    def form(attr={}, &block)
+    # Create a form tag with the given attributes. Returns an HTML string for
+    # the generated form tag.
+    def form(attr={})
       if obj && !attr[:method] && !attr['method'] && obj.respond_to?(:forme_default_request_method)
-        attr = attr.merge('method'=>obj.forme_default_request_method)
+        attr = Hash[attr]
+        attr['method'] = obj.forme_default_request_method
+      end
+      @form_tag_attributes = attr
+
+      tag(:form, attr) do
+        before_form_yield
+        yield self if block_given?
+        after_form_yield
       end
-      tag(:form, attr, method(:hidden_form_tags), &block)
     end
 
-    # Empty method designed to ease integration with other libraries where
-    # Forme is used in template code and some output implicitly
-    # created by Forme needs to be injected into the template output.
-    def emit(tag)
+    # Whether the method for this form is POST. Only callable after calling
+    # #form.
+    def post?
+      (form_tag_attributes[:method] || form_tag_attributes['method']).to_s.upcase == 'POST'
     end
 
     # Creates an +Input+ with the given +field+ and +opts+ associated with
-    # the receiver, and add it to the list of children to the currently
-    # open tag.
+    # the receiver.  Returns the HTML generated by the given input.
     #
     # If the form is associated with an +obj+, or the :obj key exists in
     # the +opts+ argument, treats the +field+ as a call to the +obj+.  If
@@ -129,36 +144,39 @@ module Forme
     # type (e.g. <tt>:text</tt>, <tt>:textarea</tt>, <tt>:select</tt>), and
     # an input is created directly with the +field+ and +opts+.
     def input(field, opts={})
-      if opts.has_key?(:obj)
-        opts = opts.dup
-        obj = opts.delete(:obj)
-      else
-        obj = self.obj
-      end
-      input = if obj
-        if obj.respond_to?(:forme_input)
-          obj.forme_input(self, field, opts.dup)
-        else
+      content_added do
+        if opts.has_key?(:obj)
           opts = opts.dup
-          opts[:key] = field unless opts.has_key?(:key)
-          type = opts.delete(:type) || :text
-          unless opts.has_key?(:value) || type == :file
-            opts[:value] = if obj.is_a?(Hash)
-              obj[field]
-            else
-              obj.send(field)
+          obj = opts.delete(:obj)
+        else
+          obj = self.obj
+        end
+
+        input = if obj
+          if obj.respond_to?(:forme_input)
+            obj.forme_input(self, field, opts.dup)
+          else
+            opts = opts.dup
+            opts[:key] = field unless opts.has_key?(:key)
+            type = opts.delete(:type) || :text
+            unless opts.has_key?(:value) || type == :file
+              opts[:value] = if obj.is_a?(Hash)
+                obj[field]
+              else
+                obj.send(field)
+              end
             end
+            _input(type, opts)
           end
-          _input(type, opts)
+        else
+          _input(field, opts)
         end
-      else
-        _input(field, opts)
+
+        self << input
       end
-      self << input
-      input
     end
 
-    # Create a new +Input+ associated with the receiver with the given
+    # Return a new +Input+ associated with the receiver with the given
     # arguments, doing no other processing.
     def _input(*a)
       Input.new(self, *a)
@@ -182,6 +200,8 @@ module Forme
     # wrapper to use for this inputs call.  You can use the :nested_inputs_wrapper
     # option to set the default :inputs_wrapper option for the duration of the block.
     #
+    # Returns the HTML generated by the inputs added to the form.
+    #
     # This can also be called with a single hash argument to just use an options hash:
     #
     #   f.inputs(:legend=>'Foo') do
@@ -193,32 +213,28 @@ module Forme
     #   f.inputs do
     #     # ...
     #   end
-    def inputs(inputs=[], opts={}, &block)
-      _inputs(inputs, opts, &block)
-    end
-    
-    # Internals of #inputs, should be used internally by the library, where #inputs
-    # is designed for external use. 
-    def _inputs(inputs=[], opts={}) # :nodoc:
-      if inputs.is_a?(Hash)
-        opts = inputs.merge(opts)
-        inputs = []
-      end
+    def inputs(inputs=[], opts={})
+      content_added do
+        if inputs.is_a?(Hash)
+          opts = inputs.merge(opts)
+          inputs = []
+        end
 
-      form_opts = {}
-      form_opts[:inputs_wrapper] = opts[:nested_inputs_wrapper] if opts[:nested_inputs_wrapper]
-      TRANSFORMER_TYPES.each do |t|
-        if opts.has_key?(t) && t != :inputs_wrapper
-          form_opts[t] = opts[t]
+        form_opts = {}
+        form_opts[:inputs_wrapper] = opts[:nested_inputs_wrapper] if opts[:nested_inputs_wrapper]
+        TRANSFORMER_TYPES.each do |t|
+          if opts.has_key?(t) && t != :inputs_wrapper
+            form_opts[t] = opts[t]
+          end
         end
-      end
 
-      Forme.transform(:inputs_wrapper, opts, @opts, self, opts) do
-        with_opts(form_opts) do
-          inputs.each do |i|
-            emit(input(*i))
+        Forme.transform(:inputs_wrapper, opts, @opts, self, opts) do
+          with_opts(form_opts) do
+            inputs.each do |i|
+              input(*i)
+            end
+            yield if block_given?
           end
-          yield if block_given?
         end
       end
     end
@@ -255,35 +271,34 @@ module Forme
     end
 
     # Creates a +Tag+ associated to the receiver with the given arguments.
-    # Add the tag to the the list of children for the currently open tag.
-    # If a block is given, make this tag the currently open tag while inside
-    # the block.
+    # If a block is given, yield to the block inside the generated tag.
+    # Returns the HTML added to the form by the addition of this tag.
     def tag(*a, &block)
-      tag = _tag(*a)
-      self << tag
-      nest(tag, &block) if block
-      tag
-    end
-
-    # Aliased for tag.  Workaround for issue with rails plugin.
-    def tag_(*a, &block) # :nodoc:
-      tag(*a, &block)
+      content_added do
+        tag = _tag(*a)
+        if block
+          self << serialize_open(tag)
+          if children = tag.children
+            children.each{|child| self << child}
+          end
+          yield self
+          self << serialize_close(tag)
+        else
+          self << tag
+        end
+      end
     end
 
-    # Creates a :submit +Input+ with the given opts, adding it to the list
-    # of children for the currently open tag.
+    # Creates a :submit +Input+ with the given opts. Returns the generated
+    # HTML for the input.
     def button(opts={})
       opts = {:value=>opts} if opts.is_a?(String)
-      input = _input(:submit, opts)
-      self << input
-      input
+      content_added{self << _input(:submit, opts)}
     end
 
-    # Add the +Input+/+Tag+ instance given to the currently open tag.
+    # Add the +Input+/+Tag+ instance to the HTML buffer.
     def <<(tag)
-      if n = @nesting.last
-        n << tag
-      end
+      @to_s << tag.to_s
     end
 
     # Calls the block for each object in objs, using with_obj with the given namespace
@@ -296,18 +311,11 @@ module Forme
       end
     end
 
-    # Return a new string that will not be html escaped by the default serializer.
+    # Return a new string that will not be HTML escaped by the default serializer.
     def raw(s)
       Forme.raw(s)
     end
 
-    # Marks the string as containing already escaped output.  Returns string given
-    # by default, but subclasses for specific web frameworks can handle automatic
-    # html escaping by overriding this.
-    def raw_output(s)
-      s
-    end
-
     # Temporarily override the given object and namespace for the form.  Any given
     # namespaces are appended to the form's current namespace.
     def with_obj(obj, namespace=nil)
@@ -338,53 +346,40 @@ module Forme
       end
     end
 
-    # Return array of hidden tags to use for this form,
-    # or nil if the form does not have hidden tags added automatically.
-    def hidden_form_tags(form_tag)
-      if hidden_tags
-        tags = []
-        hidden_tags.each do |hidden_tag|
-          hidden_tag = hidden_tag.call(form_tag) if hidden_tag.respond_to?(:call)
-          tags.concat(parse_hidden_tags(hidden_tag))
-        end
-        tags
-      end
-    end
-
-    # Handle various types of hidden tags for the form.
-    def parse_hidden_tags(hidden_tag)
-      case hidden_tag
-      when Array
-        hidden_tag
-      when Tag, String
-        [hidden_tag]
-      when Hash
-        hidden_tag.map{|k,v| _tag(:input, :type=>:hidden, :name=>k, :value=>v)}
-      when nil
-        []
-      else
-        raise Error, "unhandled hidden_tag response: #{hidden_tag.inspect}"
-      end
-    end
-
-    # Make the given tag the currently open tag, and yield.  After the
-    # block returns, make the previously open tag the currently open
-    # tag.
-    def nest(tag)
-      @nesting << tag
-      yield self
-    ensure
-      @nesting.pop
+    # Return the HTML content added by the block.
+    def content_added
+      offset = @to_s.length
+      yield
+      @to_s[offset, @to_s.length]
     end
 
     # Return a serialized opening tag for the given tag.
     def serialize_open(tag)
-      raw_output(serializer.serialize_open(tag)) if serializer.respond_to?(:serialize_open)
+      serializer.serialize_open(tag) if serializer.respond_to?(:serialize_open)
     end
 
     # Return a serialized closing tag for the given tag.
     def serialize_close(tag)
-      raw_output(serializer.serialize_close(tag)) if serializer.respond_to?(:serialize_close)
+      serializer.serialize_close(tag) if serializer.respond_to?(:serialize_close)
+    end
+
+    # Call before hooks if defined.
+    def before_form_yield
+      # _before_post and _before hooks are only for internal use
+      opts[:_before_post].call(self) if opts[:_before_post] && post?
+      opts[:_before].call(self) if opts[:_before]
+
+      # before hook is for external use
+      opts[:before].call(self) if opts[:before]
+    end
+
+    # Call after hooks if defined.
+    def after_form_yield
+      # after hook is for external use
+      opts[:after].call(self) if opts[:after]
+
+      # _after hook is only for internal use
+      opts[:_after].call(self) if opts[:_after]
     end
   end
 end

data/lib/forme/input.rb

@@ -32,7 +32,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
 
     # Transform the receiver into a lower level +Tag+ form (or an array