forme 1.2.0 → 1.3.0

data/lib/forme/transformers/helper.rb

@@ -0,0 +1,17 @@
+module Forme
+  # Default helper used by the library, using a spam with "helper" class
+  #
+  # Registered as :default.
+  class Helper
+    Forme.register_transformer(:helper, :default, new)
+
+    # Return tag with error message span tag after it.
+    def call(tag, input)
+      attr = input.opts[:helper_attr]
+      attr = attr ? attr.dup : {}
+      Forme.attr_classes(attr, 'helper')
+      [tag, input.tag(:span, attr, input.opts[:help])]
+    end
+  end
+end
+

data/lib/forme/transformers/inputs_wrapper.rb

@@ -0,0 +1,95 @@
+module Forme
+  # Default inputs_wrapper used by the library, uses a <fieldset>.
+  #
+  # Registered as :default.
+  class InputsWrapper
+    Forme.register_transformer(:inputs_wrapper, :default, new)
+
+    # Wrap the inputs in a <fieldset>.  If the :legend
+    # option is given, add a <legend> tag as the first
+    # child of the fieldset.
+    def call(form, opts)
+      attr = opts[:attr] ? opts[:attr].dup : {}
+      Forme.attr_classes(attr, 'inputs')
+      if legend = opts[:legend]
+        form.tag(:fieldset, attr) do
+          form.emit(form.tag(:legend, opts[:legend_attr], legend))
+          yield
+        end
+      else
+        form.tag(:fieldset, attr, &Proc.new)
+      end
+    end
+  end
+
+  # Use a <fieldset> and an <ol> tag to wrap the inputs.
+  #
+  # Registered as :fieldset_ol.
+  class InputsWrapper::FieldSetOL < InputsWrapper
+    Forme.register_transformer(:inputs_wrapper, :fieldset_ol, new)
+
+    # Wrap the inputs in a <fieldset> and a <ol> tag.
+    def call(form, opts)
+      super(form, opts){form.tag_(:ol){yield}}
+    end
+  end
+
+  # Use an <ol> tag to wrap the inputs.
+  #
+  # Registered as :ol.
+  class InputsWrapper::OL
+    Forme.register_transformer(:inputs_wrapper, :ol, new)
+
+    # Wrap the inputs in an <ol> tag
+    def call(form, opts, &block)
+      form.tag(:ol, opts[:attr], &block)
+    end
+  end
+
+  # Use a <div> tag to wrap the inputs.
+  #
+  # Registered as :div.
+  class InputsWrapper::Div
+    Forme.register_transformer(:inputs_wrapper, :div, new)
+
+    # Wrap the inputs in an <div> tag
+    def call(form, opts, &block)
+      form.tag(:div, opts[:attr], &block)
+    end
+  end
+
+  # Use a <tr> tag to wrap the inputs.
+  #
+  # Registered as :tr.
+  class InputsWrapper::TR
+    Forme.register_transformer(:inputs_wrapper, :tr, new)
+
+    # Wrap the inputs in an <tr> tag
+    def call(form, opts, &block)
+      form.tag(:tr, opts[:attr], &block)
+    end
+  end
+
+  # Use a <table> tag to wrap the inputs.
+  #
+  # Registered as :table.
+  class InputsWrapper::Table
+    Forme.register_transformer(:inputs_wrapper, :table, new)
+
+    # Wrap the inputs in a <table> tag.
+    def call(form, opts, &block)
+      attr = opts[:attr] ? opts[:attr].dup : {}
+      form.tag(:table, attr) do
+        if legend = opts[:legend]
+          form.emit(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)}))
+        end
+
+        yield
+      end
+    end
+  end
+end

data/lib/forme/transformers/labeler.rb

@@ -0,0 +1,78 @@
+module Forme
+  # Default labeler used by the library, using implicit labels (where the
+  # label tag encloses the other tag).
+  #
+  # Registered as :default.
+  class Labeler
+    Forme.register_transformer(:labeler, :default, new)
+
+    # Return a label tag wrapping the given tag.  For radio and checkbox
+    # inputs, the label occurs directly after the tag, for all other types,
+    # the label occurs before the tag.
+    def call(tag, input)
+      label = input.opts[:label]
+      label_position = input.opts[:label_position]
+      if [:radio, :checkbox].include?(input.type)
+        if input.type == :checkbox && tag.is_a?(Array) && tag.length == 2 && tag.first.attr[:type].to_s == 'hidden' 
+          t = if label_position == :before
+            [label, ' ', tag.last]
+          else
+            [tag.last, ' ', label]
+          end
+          return [tag.first , input.tag(:label, input.opts[:label_attr]||{}, t)]
+        elsif label_position == :before
+          t = [label, ' ', tag]
+        else
+          t = [tag, ' ', label]
+        end
+      elsif label_position == :after
+        t = [tag, ' ', label]
+      else
+        t = [label, ": ", tag]
+      end
+      input.tag(:label, input.opts[:label_attr]||{}, t)
+    end
+  end
+
+  # Explicit labeler that creates a separate label tag that references
+  # the given tag's id using a +for+ attribute.  Requires that all tags
+  # with labels have +id+ fields.
+  #
+  # Registered as :explicit.
+  class Labeler::Explicit
+    Forme.register_transformer(:labeler, :explicit, new)
+
+    # Return an array with a label tag as the first entry and +tag+ as
+    # a second entry.  If the +input+ has a :label_for option, use that,
+    # otherwise use the input's :id option.  If neither the :id or
+    # :label_for option is used, the label created will not be
+    # associated with an input.
+    def call(tag, input)
+      unless id = input.opts[:id]
+        if key = input.opts[:key]
+          namespaces = input.form_opts[:namespace]
+          id = "#{namespaces.join('_')}#{'_' unless namespaces.empty?}#{key}"
+          if key_id = input.opts[:key_id]
+            id << "_#{key_id.to_s}"
+          end
+        end
+      end
+
+      label_attr = input.opts[:label_attr]
+      label_attr = label_attr ? label_attr.dup : {}
+      label_attr[:for] ||= input.opts.fetch(:label_for, id)
+      lpos = input.opts[:label_position] || ([:radio, :checkbox].include?(input.type) ? :after : :before)
+
+      Forme.attr_classes(label_attr, "label-#{lpos}")
+      label = input.tag(:label, label_attr, [input.opts[:label]])
+
+      t = if lpos == :before
+        [label, tag]
+      else
+        [tag, label]
+      end
+
+      t
+    end
+  end
+end

data/lib/forme/transformers/serializer.rb

@@ -0,0 +1,171 @@
+module Forme
+  # Default serializer class used by the library.  Any other serializer
+  # classes that want to produce html should probably subclass this class.
+  #
+  # Registered as :default.
+  class Serializer
+    Forme.register_transformer(:serializer, :default, new)
+
+    # Borrowed from Rack::Utils, map of single character strings to html escaped versions.
+    ESCAPE_HTML = {"&" => "&amp;", "<" => "&lt;", ">" => "&gt;", "'" => "&#39;", '"' => "&quot;"}
+
+    # A regexp that matches all html characters requiring escaping.
+    ESCAPE_HTML_PATTERN = Regexp.union(*ESCAPE_HTML.keys)
+
+    # Which tags are self closing (such tags ignore children).
+    SELF_CLOSING = [:img, :input]
+
+    # Serialize the tag object to an html string.  Supports +Tag+ instances,
+    # +Input+ instances (recursing into +call+ with the result of formatting the input),
+    # arrays (recurses into +call+ for each entry and joins the result), and
+    # (html escapes the string version of them, unless they include the +Raw+
+    # module, in which case no escaping is done).
+    def call(tag)
+      case tag
+      when Tag
+        if SELF_CLOSING.include?(tag.type)
+          "<#{tag.type}#{attr_html(tag.attr)}/>"
+        else
+          "#{serialize_open(tag)}#{call(tag.children)}#{serialize_close(tag)}"
+        end
+      when Input
+        call(tag.format)
+      when Array
+        tag.map{|x| call(x)}.join
+      when DateTime, Time
+        format_time(tag)
+      when Date
+        format_date(tag)
+      when BigDecimal
+        tag.to_s('F')
+      when Raw
+        tag.to_s
+      else
+        h tag
+      end
+    end
+
+    # Returns the opening part of the given tag.
+    def serialize_open(tag)
+      "<#{tag.type}#{attr_html(tag.attr)}>"
+    end
+
+    # Returns the closing part of the given tag.
+    def serialize_close(tag)
+      "</#{tag.type}>"
+    end
+
+    private
+
+    # Return a string in ISO format representing the +Date+ instance.
+    def format_date(date)
+      date.strftime("%F")
+    end
+
+    # Return a string in ISO format representing the +Time+ or +DateTime+ instance.
+    def format_time(time)
+      time.is_a?(Time) ? (time.strftime('%Y-%m-%dT%H:%M:%S') + sprintf(".%06d", time.usec)) : (time.strftime('%Y-%m-%dT%H:%M:%S.') + time.strftime('%N')[0...6])
+    end
+
+    # Escape ampersands, brackets and quotes to their HTML/XML entities.
+    def h(string)
+      string.to_s.gsub(ESCAPE_HTML_PATTERN){|c| ESCAPE_HTML[c] }
+    end
+
+    # Join attribute values that are arrays with spaces instead of an empty
+    # string.
+    def attr_value(v)
+      if v.is_a?(Array)
+        v.map{|c| attr_value(c)}.join(' ')
+      else
+        call(v)
+      end
+    end
+
+    # Transforms the +tag+'s attributes into an html string, sorting by the keys
+    # and quoting and html escaping the values.
+    def attr_html(attr)
+      attr = attr.to_a.reject{|k,v| v.nil?}
+      " #{attr.map{|k, v| "#{k}=\"#{attr_value(v)}\""}.sort.join(' ')}" unless attr.empty?
+    end
+  end
+
+  # Overrides formatting of dates and times to use an American format without
+  # timezones.
+  class Serializer::AmericanTime < Serializer
+    Forme.register_transformer(:serializer, :html_usa, new)
+
+    def call(tag)
+      case tag
+      when Tag
+        if tag.type.to_s == 'input' && %w'date datetime datetime-local'.include?((tag.attr[:type] || tag.attr['type']).to_s)
+          attr = tag.attr.dup
+          attr.delete(:type)
+          attr.delete('type')
+          attr['type'] = 'text'
+          "<#{tag.type}#{attr_html(attr)}/>"
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+
+    private
+
+    # Return a string in American format representing the +Date+ instance.
+    def format_date(date)
+      date.strftime("%m/%d/%Y")
+    end
+
+    # Return a string in American format representing the +Time+ or +DateTime+ instance, without the timezone.
+    def format_time(time)
+      time.strftime("%m/%d/%Y %I:%M:%S%p")
+    end
+  end
+
+  # Serializer class that converts tags to plain text strings.
+  #
+  # Registered at :text.
+  class Serializer::PlainText
+    Forme.register_transformer(:serializer, :text, new)
+
+    # Serialize the tag to plain text string.
+    def call(tag)
+      case tag
+      when Tag
+        case tag.type.to_sym
+        when :input
+          case tag.attr[:type].to_sym
+          when :radio, :checkbox
+            tag.attr[:checked] ? '_X_' : '___'
+          when :submit, :reset, :hidden
+            ''
+          when :password
+            "********\n"
+          else
+            "#{tag.attr[:value].to_s}\n"
+          end
+        when :select
+          "\n#{call(tag.children)}"
+        when :option
+          "#{call([tag.attr[:selected] ? '_X_ ' : '___ ', tag.children])}\n"
+        when :textarea, :label
+          "#{call(tag.children)}\n"
+        when :legend
+          v = call(tag.children)
+          "#{v}\n#{'-' * v.length}\n"
+        else
+          call(tag.children)
+        end
+      when Input
+        call(tag.format)
+      when Array
+        tag.map{|x| call(x)}.join
+      else
+        tag.to_s
+      end
+    end
+  end
+end

data/lib/forme/transformers/wrapper.rb

@@ -0,0 +1,52 @@
+module Forme
+  # Default wrapper doesn't wrap input in any tag
+  class Wrapper
+    # Return an array containing the tag
+    def call(tag, input)
+      Array(tag)
+    end
+
+    Forme.register_transformer(:wrapper, :default, new)
+  end
+
+  # Wraps inputs using the given tag type.
+  class Wrapper::Tag < Wrapper
+    # Set the tag type to use.
+    def initialize(type)
+      @type = type
+    end
+
+    # Wrap the input in the tag of the given type.
+    def call(tag, input)
+      input.tag(@type, input.opts[:wrapper_attr], super)
+    end
+
+    [:li, :p, :div, :span, :td].each do |x|
+      Forme.register_transformer(:wrapper, x, new(x))
+    end
+  end
+
+  class Wrapper::TableRow < Wrapper
+    # Wrap the input in tr and td tags.
+    def call(tag, input)
+      a = super.flatten
+      labels, other = a.partition{|e| e.is_a?(Tag) && e.type.to_s == 'label'}
+      if labels.length == 1
+        ltd = labels
+        rtd = other
+      elsif a.length == 1
+        ltd = [a.first]
+        rtd = a[1..-1]
+      else
+        ltd = a
+      end
+      input.tag(:tr, input.opts[:wrapper_attr], [input.tag(:td, {}, ltd), input.tag(:td, {}, rtd)])
+    end
+
+    Forme.register_transformer(:wrapper, :trtd, new)
+  end
+
+  {:tr=>:td, :table=>:trtd, :ol=>:li, :fieldset_ol=>:li}.each do |k, v|
+    register_transformer(:wrapper, k, TRANSFORMERS[:wrapper][v])
+  end
+end

data/lib/forme/version.rb

@@ -1,6 +1,6 @@
 module Forme
   # Version constant, use <tt>Forme.version</tt> instead.
-  VERSION = '1.2.0'.freeze
+  VERSION = '1.3.0'.freeze
 
   # Returns the version as a frozen string (e.g. '0.1.0')
   def self.version

data/lib/sequel/plugins/forme.rb

@@ -53,6 +53,8 @@ module Sequel # :nodoc:
         #            be created via the :inputs option.  If you are not providing
         #            an :inputs option or are using a block with additional inputs,
         #            you should specify this option.
+        # :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)
@@ -62,7 +64,7 @@ module Sequel # :nodoc:
 
           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?
+              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)
@@ -245,7 +247,7 @@ module Sequel # :nodoc:
           if meth = opts.delete(:name_method)
             meth
           else
-            meths = FORME_NAME_METHODS & ref.associated_class.instance_methods.map{|s| s.to_sym}
+            meths = FORME_NAME_METHODS & ref.associated_class.instance_methods.map(&:to_sym)
             if meths.empty?
               raise Error, "No suitable name method found for association #{ref[:name]}"
             else
@@ -289,7 +291,8 @@ module Sequel # :nodoc:
           label = klass.send(:singularize, ref[:name])
 
           field = if ref[:type] == :pg_array_to_many
-            ref[:key]
+            handle_errors(key)
+            key
           else
             "#{label}_pks"
           end
@@ -361,7 +364,7 @@ module Sequel # :nodoc:
           when :select
             v = opts[:value] || obj.send(field)
             opts[:value] = (v ? 't' : 'f') unless v.nil?
-            opts[:add_blank] = true
+            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