forme 1.9.0 → 2.0.0

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,11 +224,11 @@ 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
-        form.tag(:fieldset, attr, &Proc.new)
+        form.tag(:fieldset, attr, &block)
       end
     end
   end
@@ -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,6 +1,6 @@
 # frozen-string-literal: true
 
-require 'forme/erb_form'
+require_relative 'template'
 
 module Forme
   module ERB 
@@ -14,23 +14,25 @@ module Forme
       HIDDEN_TAGS << block
     end
 
-    # 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)}
+    # 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
+
+      private
+
+      def _forme_form_options(obj, attr, opts)
+        super
+
+        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
 
-    # 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)
+      def _forme_form_hidden_tags
+        HIDDEN_TAGS
       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
@@ -16,10 +15,17 @@ module Forme
     # 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 +36,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
@@ -59,13 +51,33 @@ module Forme
       ins = opts[:inputs]
       button = opts[:button]
       if ins || button
-        block = Proc.new do |form|
-          form._inputs(ins, opts) if ins
+        block = proc do |form|
+          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
 
@@ -98,26 +110,38 @@ module Forme
       @serializer = @opts[:serializer]
       @input_defaults = @opts[:input_defaults] || {}
       @hidden_tags = @opts[:hidden_tags]
-      @nesting = []
+      if @hidden_tags && !@hidden_tags.empty? && RUBY_VERSION >= '2'
+        uplevel = 6
+        uplevel += @opts[:hidden_tags_uplevel] if @opts[:hidden_tags_uplevel]
+        warn("The Forme::Form :hidden_tags option is deprecated, please switch to using the :before option", :uplevel=>uplevel)
+      end
+      @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, method(:hidden_form_tags)) 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 +153,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 +209,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 +222,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 +280,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 +320,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)
@@ -367,24 +384,40 @@ module Forme
       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

data/lib/forme/rails.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-require 'forme'
+require_relative 'template'
 
 class ActiveSupport::SafeBuffer
   include Forme::Raw
@@ -18,94 +18,63 @@ module Forme
       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
+
+    ERB = Template::Helper.clone
+    module ERB
+      alias _forme form
+      remove_method :form
 
-      # Capture the inputs into a new output buffer, and return
-      # the buffer if not given a block
-      def inputs(*)
+      def forme(*a, &block)
         if block_given?
-          super
+          with_output_buffer{_forme(*a, &block)}
         else
-          template.send(:with_output_buffer){super}
+          raw(_forme(*a, &block))
         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
-        else
-          emit(super)
-        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
+      private
 
-      # Use the template's raw method to mark the given string as html safe.
-      def raw_output(s)
-        template.raw(s)
-      end
-
-      # 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
+      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
+        opts[:hidden_tags_uplevel] = 2
       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))
+
+      # The class to use for forms
+      def _forme_form_class
+        TemplateForm
       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)
+      def _forme_form_hidden_tags
+        Forme::Rails::HIDDEN_TAGS
       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