forme 0.6.0 → 0.7.0

data/CHANGELOG

@@ -1,3 +1,31 @@
+=== 0.7.0 (2012-05-02)
+
+* Support :label_position option in both of the labelers, can be set to :before or :after to override the default (jeremyevans)
+
+* Add Rails integration (jeremyevans)
+
+* Make explicit labeler put label after checkboxes and radio buttons instead of before (jeremyevans)
+
+* Make implicit labeler not include hidden checkbox inside label (jeremyevans)
+
+* Recognize :cols and :rows options as attributes for textarea inputs in the default formatter (jeremyevans)
+
+* Recognize :size and :maxlength options as attributes for text inputs in the default formatter (jeremyevans)
+
+* Recognize :style option as attributes in the default formatter (jeremyevans)
+
+* Join attribute values specified as arrays with spaces instead of the empty string (jeremyevans)
+
+* Make Sinatra ERB integration work with partials (jeremyevans)
+
+* Add id attributes for association :as=>:radio or :as=>:checkbox fields (jeremyevans)
+
+* Add an html class attribute for radio/checkbox labels in :as=>:radio or :as=>:checkbox fields (jeremyevans)
+
+* Wrap text acting as a label in a span with class label for :as=>:radio or :as=>:checkbox fields (jeremyevans)
+
+* Support overriding the true/false label and values for select boolean fields in the Sequel plugin (jeremyevans)
+
 === 0.6.0 (2011-08-01)
 
 * Fix wrapping for :as=>:radio boolean fields to handle them like association :as=>:radio fields (jeremyevans)

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Jeremy Evans
+Copyright (c) 2011-2012 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README.rdoc

@@ -200,7 +200,7 @@ The Forme Sequel plugin also integerates with Sequel's validation reflection sup
 +validation_class_methods+ plugin that ships with Sequel.  It will add +pattern+ and +maxlength+ attributes
 based on the format, numericality, and length validations.
 
-= Sinatra ERB Support
+= Sinatra Support
 
 Forme ships with a Sinatra extension that you can get by <tt>require "forme/sinatra"</tt> and using
 <tt>helpers Forme::Sinatra::ERB</tt> in your Sinatra::Base subclass.  It allows you to use the
@@ -213,7 +213,23 @@ following API in your Sinatra ERB forms:
     <% end %>
   <% end %>
 
-In addition to ERB, it also works with Sinatra's Erubis support.
+This example is for ERB/Erubis.  Other Sinatra template libraries work differently and
+probably do not support this integration.
+
+= Rails Support
+
+Forme ships with a Rails extension that you can get by <tt>require "forme/rails"</tt> and using
+<tt>helpers Forme::Rails::ERB</tt> in your controller.  If allows you to use the following API
+in your Rails forms:
+
+  <%= forme(@obj, :action=>'/foo') do |f| %>
+    <%= f.input(:field) %>
+    <%= f.tag(:fieldset) do %>
+      <%= f.input(:field_two) %>
+    <% end %>
+  <% end %>
+
+This has been tested on Rails 3.2, but should hopefully work on Rails 3.0+.
 
 = Other Similar Projects
 

data/Rakefile

@@ -1,10 +1,5 @@
 require "rake"
 require "rake/clean"
-begin
-  require "hanna/rdoctask"
-rescue LoadError
-  require "rake/rdoctask"
-end
 
 NAME = 'forme'
 VERS = lambda do
@@ -12,8 +7,6 @@ VERS = lambda do
   Forme.version
 end
 CLEAN.include ["#{NAME}-*.gem", "rdoc", "coverage", '**/*.rbc']
-RDOC_DEFAULT_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', 'Forme']
-RDOC_OPTS = RDOC_DEFAULT_OPTS + ['--main', 'README.rdoc']
 
 # Gem Packaging and Release
 
@@ -29,7 +22,20 @@ end
 
 ### RDoc
 
-Rake::RDocTask.new do |rdoc|
+RDOC_DEFAULT_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', 'Forme']
+
+rdoc_task_class = begin
+  require "rdoc/task"
+  RDOC_DEFAULT_OPTS.concat(['-f', 'hanna'])
+  RDoc::Task
+rescue LoadError
+  require "rake/rdoctask"
+  Rake::RDocTask
+end
+
+RDOC_OPTS = RDOC_DEFAULT_OPTS + ['--main', 'README.rdoc']
+
+rdoc_task_class.new do |rdoc|
   rdoc.rdoc_dir = "rdoc"
   rdoc.options += RDOC_OPTS
   rdoc.rdoc_files.add %w"README.rdoc CHANGELOG MIT-LICENSE lib/**/*.rb"

data/lib/forme.rb

@@ -205,7 +205,7 @@ module Forme
       button = opts[:button]
       if ins || button
         block = Proc.new 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
         end
@@ -354,7 +354,13 @@ module Forme
     # The given +opts+ are passed to the +inputs_wrapper+, and the default
     # +inputs_wrapper+ supports a <tt>:legend</tt> option that is used to
     # set the legend for the fieldset.
-    def inputs(inputs=[], opts={})
+    def inputs(*a, &block)
+      _inputs(*a, &block)
+    end
+    
+    # Internals of #inputs, should be used internally by the library, where #inputs
+    # is designed for external use.
+    def _inputs(inputs=[], opts={})
       if inputs.is_a?(Hash)
         opts = inputs.merge(opts)
         inputs = []
@@ -396,6 +402,10 @@ module Forme
       tag
     end
 
+    def tag_(*a, &block)
+      tag(*a, &block)
+    end
+
     # Creates a :submit +Input+ with the given opts, adding it to the list
     # of children for the currently open tag.
     def button(opts={})
@@ -585,7 +595,7 @@ module Forme
     # attributes hash, so they don't need to be specified in the :attr
     # option.  However, they can be specified in both places, and if so,
     # the :attr option version takes precedence.
-    ATTRIBUTE_OPTIONS = [:name, :id, :placeholder, :value]
+    ATTRIBUTE_OPTIONS = [:name, :id, :placeholder, :value, :style]
 
     # Create a new instance and call it
     def self.call(input)
@@ -719,6 +729,7 @@ module Forme
     # with the type attribute set to input.
     def _format_input(type)
       @attr[:type] = type
+      copy_options_to_attributes([:size, :maxlength])
       tag(:input)
     end
 
@@ -789,6 +800,7 @@ module Forme
     # Formats a textarea.  Respects the following options:
     # :value :: Sets value as the child of the textarea.
     def format_textarea
+      copy_options_to_attributes([:cols, :rows])
       if val = @attr.delete(:value)
         tag(:textarea, @attr, [val])
       else
@@ -796,15 +808,19 @@ module Forme
       end
     end
 
-    # Normalize the options used for all input types.  Handles:
-    # :required :: Sets the +required+ attribute on the resulting tag if true.
-    # :disabled :: Sets the +disabled+ attribute on the resulting tag if true.
-    def normalize_options
-      ATTRIBUTE_OPTIONS.each do |k|
+    def copy_options_to_attributes(attributes)
+      attributes.each do |k|
         if @opts.has_key?(k) && !@attr.has_key?(k)
           @attr[k] = @opts[k]
         end
       end
+    end
+
+    # Normalize the options used for all input types.  Handles:
+    # :required :: Sets the +required+ attribute on the resulting tag if true.
+    # :disabled :: Sets the +disabled+ attribute on the resulting tag if true.
+    def normalize_options
+      copy_options_to_attributes(ATTRIBUTE_OPTIONS)
 
       Forme.attr_classes(@attr, @opts[:class]) if @opts.has_key?(:class)
       Forme.attr_classes(@attr, 'error') if @opts[:error]
@@ -928,10 +944,24 @@ module Forme
     # the label occurs before the tag.
     def call(tag, input)
       label = input.opts[:label]
-      t = if [:radio, :checkbox].include?(input.type)
-        [tag, ' ', 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
-        [label, ": ", tag]
+        t = [label, ": ", tag]
       end
       input.tag(:label, input.opts[:label_attr]||{}, t)
     end
@@ -951,7 +981,18 @@ module Forme
     # :label_for option is used, the label created will not be
     # associated with an input.
     def call(tag, input)
-      [input.tag(:label, {:for=>input.opts.fetch(:label_for, input.opts[:id])}.merge(input.opts[:label_attr]||{}), [input.opts[:label]]), tag]
+      if [:radio, :checkbox].include?(input.type)
+        t = [tag, input.tag(:label, {:for=>input.opts.fetch(:label_for, input.opts[:id])}.merge(input.opts[:label_attr]||{}), [input.opts[:label]])]
+        p = :before
+      else
+        t = [input.tag(:label, {:for=>input.opts.fetch(:label_for, input.opts[:id])}.merge(input.opts[:label_attr]||{}), [input.opts[:label]]), tag]
+        p = :after
+      end
+      if input.opts[:label_position] == p
+        t.reverse
+      else
+        t
+      end
     end
   end
 
@@ -995,7 +1036,7 @@ module Forme
 
     # Wrap the inputs in an ol tag
     def call(form, opts)
-      super(form, opts){form.tag(:ol){yield}}
+      super(form, opts){form.tag_(:ol){yield}}
     end
   end
 
@@ -1106,11 +1147,21 @@ module Forme
       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(tag)
       attr = tag.attr.to_a.reject{|k,v| v.nil?}
-      " #{attr.map{|k, v| "#{k}=\"#{call(v)}\""}.sort.join(' ')}" unless attr.empty?
+      " #{attr.map{|k, v| "#{k}=\"#{attr_value(v)}\""}.sort.join(' ')}" unless attr.empty?
     end
   end
 

data/lib/forme/rails.rb

@@ -0,0 +1,99 @@
+require 'forme'
+
+module Forme
+  module Rails # :nodoc:
+    # 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]
+      end
+
+      # Serialize and mark as already escaped the string version of
+      # the input.
+      def emit(tag)
+        template.output_buffer << template.raw(tag.to_s)
+      end
+
+      # Capture the inputs into a new output buffer, and return
+      # the buffer if not given a block
+      def inputs(*)
+        if block_given?
+          super
+        else
+          template.send(:with_output_buffer){super}
+        end
+      end
+      
+      # If a block is not given, emit the inputs into the current output
+      # buffer.
+      def _inputs(*)
+        if block_given?
+          super
+        else
+          emit(super)
+        end
+      end
+
+      # Return a string version of the input that is already marked as safe.
+      def input(*)
+        template.raw(super.to_s)
+      end
+
+      # Return a string version of the button that is already marked as safe.
+      def button(*)
+        template.raw(super.to_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 = _tag(type, attr, children)
+          template.raw(tag.to_s)
+        end
+      end
+
+      def tag_(type, attr={}, children=[])
+        tag = _tag(type, attr, children)
+        emit(serializer.serialize_open(tag)) if serializer.respond_to?(:serialize_open)
+        Array(children).each{|c| emit(c)}
+        yield self if block_given?
+        emit(serializer.serialize_close(tag)) if serializer.respond_to?(:serialize_close)
+      end
+    end
+
+    module ERB
+      # Create a +Form+ object 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 forme(obj=nil, attr={}, opts={}, &block)
+        h = {:template=>self}
+        (obj.is_a?(Hash) ? attr = attr.merge(h) : opts = opts.merge(h))
+        Form.form(obj, attr, opts, &block)
+      end
+    end
+  end
+end

data/lib/forme/sinatra.rb

@@ -13,7 +13,7 @@ module Forme
       # Set the template output object when initializing.
       def initialize(*)
         super
-        @output = @opts[:output]
+        @output = @opts[:output] ? @opts[:output] : ''
       end
 
       # Serialize the tag and inject it into the output.
@@ -21,37 +21,51 @@ module Forme
         output << tag.to_s
       end
 
-      # Always return nil, so that use with <%= doesn't cause
-      # multiple things to be output. 
-      def inputs(*a)
-        super
-        nil
+      # 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 inputs(*a, &block)
+        if block
+          capture(block){super}
+        else
+          capture{super}
+        end
       end
 
-      # Always return nil, so that use with <%= doesn't cause
-      # multiple things to be output. 
+      # Capture the inside of the form, injecting it into the template if
+      # a block is given, or returning it as a string if not.
       def form(*a, &block)
-        super
-        nil
+        if block
+          capture(block){super}
+        else
+          capture{super}
+        end
       end
 
-      # If a block is provided, inject an opening tag into the
+      # If a block is given, inject an opening tag into the
       # output, inject any given children into the output, yield to the
-      # block, inject a closing tag into the output, and the return nil
-      # so that usage with <%= doesn't cause multiple things to be output.
+      # block, inject a closing tag into the output.
       # If a block is not given, just return the tag created.
-      def tag(type, attr={}, children=[])
+      def tag(type, attr={}, children=[], &block)
         tag = _tag(type, attr, children)
-        if block_given?
-          emit(serializer.serialize_open(tag)) if serializer.respond_to?(:serialize_open)
-          children.each{|c| emit(c)}
-          yield self
-          emit(serializer.serialize_close(tag)) if serializer.respond_to?(:serialize_close)
-          nil
+        if block
+          capture(block) do
+            emit(serializer.serialize_open(tag)) if serializer.respond_to?(:serialize_open)
+            children.each{|c| emit(c)}
+            yield self
+            emit(serializer.serialize_close(tag)) if serializer.respond_to?(:serialize_close)
+          end
         else
           tag
         end
       end
+
+      def capture(block='')
+        buf_was, @output = @output, block.is_a?(Proc) ? (eval("@_out_buf", block.binding) || @output) : block
+        yield
+        ret = @output
+        @output = buf_was
+        ret
+      end
     end
     
     # This is the module used to add the Forme integration
@@ -77,9 +91,13 @@ module Forme
       #                                  opening attributes, third if provided is
       #                                  +Form+'s options.
       def form(obj=nil, attr={}, opts={}, &block)
-        h = {:output=>@_out_buf}
-        (obj.is_a?(Hash) ? attr = attr.merge(h) : opts = opts.merge(h))
-        Form.form(obj, attr, opts, &block)
+        if block
+          h = {:output=>@_out_buf}
+          (obj.is_a?(Hash) ? attr = attr.merge(h) : opts = opts.merge(h))
+          Form.form(obj, attr, opts, &block)
+        else
+          Form.form(obj, attr, opts)
+        end
       end
     end