campo 0.2.0

data/.gitignore

@@ -0,0 +1,17 @@
+.DS_Store
+*.swp
+
+.rvmrc
+*.tmproj
+key
+log/
+files/
+thin/
+.sass-cache/
+run/
+app/.sass-cache/
+scratch/
+*.gem
+coverage/
+.yardoc/
+docs/

data/CHANGES

@@ -0,0 +1,65 @@
+v0.2.0 All Base fields can now take a block and the convenience methodsl, allowing them to nest other elements regardless of whether the parent is a form or a select. This basically makes it a lot easier to use a literal as the root of the document.
+
+v0.1.1 Label naming a bit better... possibly! It breaks on _ and capitalises when trying for a default.
+
+v0.1.0 Added support for helper methods in amongst haml attributes.  More convenience methods like `radio`. Support for nesting of fieldsets. `.select` takes a block too.
+
+v0.0.30 Changed main output to allow a whole form to be wrapped in a literal, for instance when wanting to wrap it in a div. Fragments now require 'false' to be passed along with the tag class. No change for whole forms.
+
+v0.0.29 Added more tests and a couple of convenience methods - bit_of_ruby and literal.
+
+v0.0.28 Somehow a typo that caused a bug got committed. Fixed it.
+
+v0.0.27 changes to allow fragments to be output without the variable declarations at the top, and for all children to output too.
+
+v0.0.26 Bugfix
+
+v0.0.25 Added checkbox convenience method.
+
+v0.0.24 Fixed inners for textarea, properly evaluated now, and slight change to submit button so it's not passed on submit as a parameter.
+
+v0.0.23 Inners are capitalised and attributes downcased, to make using convenience methods more convenient.
+
+v0.0.22 Bugfixes, bit of internal rejigging, and fieldset convenience method now takes a block, it's more natural.
+
+v0.0.21 Added convenience method for Textarea.
+
+v0.0.20 Bugfixes to Textarea and some other bits of assignment code, as it just didn't work.
+
+v0.0.19 Added convenience method for submit button.
+
+v0.0.18 Fix to errors caused by attributes that aren't strings; labelling can be added by .method or by push.
+
+v0.0.17 Bug fix/internal API change, forced by changes in 0.0.16
+
+v0.0.16 can pass a ruby insert for Haml to a select tag
+
+v0.0.15 Select#with_default can now be used with an and array and/or a block.
+
+v0.0.14 Added some specs and made minor changes to code.
+
+v0.0.13 Added convenience methods for adding text and select tags (with a default option tag), and problem with spaces in names/values for attribute methods.
+
+v0.0.12 Tab index for fields is automatically generated.
+
+v0.0.11 No need to explicitly give a label the name, it picks it up from the field.
+
+v0.0.10 All options get id's and locals too.
+
+v0.0.9 Added fieldsets and legends.
+
+v0.0.8 Adds id's to input fields, making accessible labels.
+
+v0.0.7 Select tags with dynamic option tags possible.
+
+v0.0.6 Added in another local, called inners for dynamic inner stuff. Changed locals to atts as it was messing up sinatra/haml. Added in more defaults to locals to avoid errors.
+
+v0.0.5 Added in locals, which makes the parts of the form (possibly) dynamic.
+
+v0.0.4 Moved output delegates to blocks on path to adding locals easier.
+
+v0.0.3 Simplified API, removed unnecessary classes
+
+v0.0.2 Submit button and convenience method for output.
+
+v0.0.1 Input text fields, textarea, with labels.

data/README.markdown

@@ -0,0 +1,276 @@
+# Campo #
+
+A static dynamic form builder into haml. Yep, static _and_ dynamic. Use it to statically create a form into haml, but you may notice it's taken advantage of haml's "add a hash to the front of the attributes and it'll get merged" property. http://haml-lang.com/docs/yardoc/file.HAML\_REFERENCE.html#attribute_methods. More on that below.
+
+Btw, I'll be using this with Sinatra, if you're using Rails you'll need to work out how that's done as I don't know.
+
+## Why though? ##
+
+However nice Haml is, it's still a lot of effort to build a form. If you've got lots of forms it's worse. The long term plan is to link this in to Sequel.
+
+## Example! ##
+
+Here's an example form:
+
+    # This bit is to simulate the output I'd usually get from calling a database model for a lookup table
+    genders = [["1", "Male"], ["2", "Female"]]
+
+    # Now starts the real action #
+    
+    form = Campo.form "myform", action: "/my/form/update/"
+
+    form.fieldset "Your details" do |f|
+      f.text "full_name",  size: 60 
+      f.text "dob", "Date of birth: ", size: 8
+      
+      f.select( "gender_id", {opts: genders }).with_default.labelled( "Gender: " )
+      
+      f.select "teas" do |s|
+        s.with_default
+        s.option("ceylon")
+        s.option("breakfast")
+        s.option("earl grey")
+        s.option("oolong")
+        s.option("sencha")
+      end.labelled "Favourite tea:"
+      
+      f.text "occupation", "Occupation: ", size: 60  
+      f.text "phone_landline", "Phone  landline : ", size: 20  
+      f.text "phone_mobile", "Phone  mobile : ", size: 20  
+
+      f.submit "Save"
+  
+    end
+
+and the output:
+
+
+    puts Campo.output( form )
+
+    - atts = {} if atts.nil?
+    - atts.default = {} if atts.default.nil?
+    - inners.default = "" if inners.default.nil?
+    - i = 0 # for tabindex
+
+    %form{ atts[:myform], method: "POST", action: "/my/form/update/", name: "myform",  }
+      %fieldset{  }
+        %legend{  }Your details
+        %label{ for: "full_name",  }
+          Full name: 
+          %input{ atts[:full_name], tabindex: "#{i += 1}", type: "text", id: "full_name", size: "60", name: "full_name",  }
+        %label{ for: "dob",  }
+          Date of birth: 
+          %input{ atts[:dob], tabindex: "#{i += 1}", type: "text", id: "dob", size: "8", name: "dob",  }
+        %label{ for: "gender_id",  }
+          Gender: 
+          %select{ atts[:gender_id], tabindex: "#{i += 1}", name: "gender_id",  }
+            %option{  value: "", disabled: "disabled", name: "gender_id",  }Choose one:
+            %option{ atts[:gender_id_1], value: "1", id: "gender_id_1", name: "gender_id",  }Male
+            %option{ atts[:gender_id_2], value: "2", id: "gender_id_2", name: "gender_id",  }Female
+        %label{ for: "teas",  }
+          Favourite tea:
+          %select{ atts[:teas], tabindex: "#{i += 1}", name: "teas",  }
+            %option{  value: "", disabled: "disabled", name: "teas",  }Choose one:
+            %option{ atts[:teas_ceylon], value: "ceylon", id: "teas_ceylon", name: "teas",  }Ceylon
+            %option{ atts[:teas_breakfast], value: "breakfast", id: "teas_breakfast", name: "teas",  }Breakfast
+            %option{ atts[:teas_earl_grey], value: "earl grey", id: "teas_earl_grey", name: "teas",  }Earl grey
+            %option{ atts[:teas_oolong], value: "oolong", id: "teas_oolong", name: "teas",  }Oolong
+            %option{ atts[:teas_sencha], value: "sencha", id: "teas_sencha", name: "teas",  }Sencha
+        %label{ for: "occupation",  }
+          Occupation: 
+          %input{ atts[:occupation], tabindex: "#{i += 1}", type: "text", id: "occupation", size: "60", name: "occupation",  }
+        %label{ for: "phone_landline",  }
+          Phone (landline): 
+          %input{ atts[:phone_landline], tabindex: "#{i += 1}", type: "text", id: "phone_landline", size: "20", name: "phone_landline",  }
+        %label{ for: "phone_mobile",  }
+          Phone (mobile): 
+          %input{ atts[:phone_mobile], tabindex: "#{i += 1}", type: "text", id: "phone_mobile", size: "20", name: "phone_mobile",  }
+        %input{ atts[:Save_Save], tabindex: "#{i += 1}", type: "submit", id: "Save_Save", value: "Save",  }
+
+and that outputs:
+
+    puts Haml::Engine.new( Campo.output( form ) ).render
+    
+    <form action='/my/form/update/' method='POST' name='myform'>
+      <fieldset>
+        <legend>Your details</legend>
+        <label for='full_name'>
+          Full name:
+          <input id='full_name' name='full_name' size='60' tabindex='1' type='text' />
+        </label>
+          Date of birth:
+          <input id='dob' name='dob' size='8' tabindex='2' type='text' />
+        </label>
+        <label for='gender_id'>
+          Gender:
+          <select name='gender_id' tabindex='3'>
+            <option disabled='disabled' name='gender_id' value=''>Choose one:</option>
+            <option id='gender_id_1' name='gender_id' value='1'>Male</option>
+            <option id='gender_id_2' name='gender_id' value='2'>Female</option>
+          </select>
+        </label>
+        <label for='teas'>
+          Favourite tea:
+          <select name='teas' tabindex='4'>
+            <option disabled='disabled' name='teas' value=''>Choose one:</option>
+            <option id='teas_ceylon' name='teas' value='ceylon'>Ceylon</option>
+            <option id='teas_breakfast' name='teas' value='breakfast'>Breakfast</option>
+            <option id='teas_earl_grey' name='teas' value='earl grey'>Earl grey</option>
+            <option id='teas_oolong' name='teas' value='oolong'>Oolong</option>
+            <option id='teas_sencha' name='teas' value='sencha'>Sencha</option>
+          </select>
+        </label>
+        <label for='occupation'>
+          Occupation:
+          <input id='occupation' name='occupation' size='60' tabindex='5' type='text' />
+        </label>
+        <label for='phone_landline'>
+          Phone (landline):
+          <input id='phone_landline' name='phone_landline' size='20' tabindex='6' type='text' />
+        </label>
+        <label for='phone_mobile'>
+          Phone (mobile):
+          <input id='phone_mobile' name='phone_mobile' size='20' tabindex='7' type='text' />
+        </label>
+        <input id='Save_Save' tabindex='8' type='submit' value='Save' />
+      </fieldset>
+    </form>
+
+
+Back to the dynamic attributes mentioned earlier. What does this mean? You can pass in a local to dynamically alter the form based on server side logic.
+
+These get added to the top, to provide sane defaults:
+
+    - atts = {} if atts.nil?
+    - atts.default = {} if atts.default.nil?
+    - inners = {} if inners.nil?
+    - inners.default = "" if inners.default.nil?
+
+In the select tag (below), notice how each tag gets a local variable added to the front. You can either fill that variable with a hash pair, or an empty hash gets passed and nothing happens.
+
+Here's the Campo code:
+
+    form = Campo.form "best_bands", action: "/best/bands/" do |form|
+      form.select("bands").option("Suede").option("Blur").option("Oasis").option("Echobelly").option("Pulp").option("Supergrass").with_default.labelled("Favourite band:")
+    end
+    
+or
+
+    form = Campo.form "best_bands", action: "/best/bands/"
+    form.select("bands") do |s|
+      s.with_default
+      s.option("Suede")
+      s.option("Blur")
+      s.option("Oasis")
+      s.option("Echobelly")
+      s.option("Pulp")
+      s.option("Supergrass")
+    end.labelled("Favourite band:")
+ 
+(or mix and match blocks, .new, arrays and hashes)   
+    
+    Campo.output form # generate the haml
+
+
+And the Haml generated:
+
+    %form{ atts[:best_bands], method: "POST", action: "/best/bands/", name: "best_bands",  }
+      %label{ for: "bands",  }
+        Favourite band:
+        %select{ atts[:bands], tabindex: "#{i += 1}", name: "bands",  }
+          %option{  value: "", disabled: "disabled", name: "bands",  }Choose one:
+          %option{ atts[:bands_suede], value: "Suede", id: "bands_suede", name: "bands",  }Suede
+          %option{ atts[:bands_blur], value: "Blur", id: "bands_blur", name: "bands",  }Blur
+          %option{ atts[:bands_oasis], value: "Oasis", id: "bands_oasis", name: "bands",  }Oasis
+          %option{ atts[:bands_echobelly], value: "Echobelly", id: "bands_echobelly", name: "bands",  }Echobelly
+          %option{ atts[:bands_pulp], value: "Pulp", id: "bands_pulp", name: "bands",  }Pulp
+          %option{ atts[:bands_supergrass], value: "Supergrass", id: "bands_supergrass", name: "bands",  }Supergrass
+
+
+If you wanted to select "Blur" dynamically (and you should, but I'd accept Suede) you might do:
+
+    atts[:bands_blur] = {selected: "selected"}
+
+and pass it in to the form when the view is rendered, and the tag would change from:
+
+    <option id='bands_blur' name='bands' value='Blur'>Blur</option>
+
+to:
+
+    <option selected='selected' id='bands_blur' name='bands' value='Blur'>Blur</option>
+
+You can do this with any kind of attribute you wish to add. For example:
+
+
+    atts[:bands_blur] = {not_worth_listening_to: "selected"}
+
+If you want to use helpers in the attributes, like sinatra's `uri` helper, then add a quote to the front:
+
+    form = Campo::Form.new "best_bands", action: %Q!"uri("/best/bands/")!
+
+outputs:
+
+    %form{ atts[:best_bands], method: "POST", action: uri("/best/bands/"), name: "best_bands",  }
+    
+If the helper isn't among the attributes, add a "=" to the front as you would in the haml:
+
+    form.bit_of_ruby( "= 5 + 1" ) }
+
+outputs:
+    
+    %form{ atts[:best_bands], method: "POST", action: uri("/best/bands/"), name: "best_bands",  }
+      = 5 + 1
+
+It's really just a literal:
+
+
+    form = Campo.form "favourite_teas", action: %Q!"uri("/fav/teas/")! do |form|
+      form.select("teas").with_default.option("ceylon").option("breakfast").option("earl grey").labelled("Favourite tea:") 
+      form.literal %Q<%p= "I like tea!">
+    end
+    Campo.output form
+  
+
+    %form{ atts[:favourite_teas], method: "POST", action: uri("/fav/teas/"), name: "favourite_teas",  }
+      %label{ for: "teas",  }
+        Favourite tea:
+        %select{ atts[:teas], tabindex: "#{i += 1}", name: "teas",  }
+          %option{  value: "", disabled: "disabled", name: "teas",  }Choose one:
+          %option{ atts[:teas_ceylon], value: "ceylon", id: "teas_ceylon", name: "teas",  }Ceylon
+          %option{ atts[:teas_breakfast], value: "breakfast", id: "teas_breakfast", name: "teas",  }Breakfast
+          %option{ atts[:teas_earl_grey], value: "earl grey", id: "teas_earl_grey", name: "teas",  }Earl grey
+      %p= "I like tea!"
+      
+    puts Haml::Engine.new( Campo.output form ).render
+    
+    <form action='/fav/teas/' method='POST' name='favourite_teas'>
+      <label for='teas'>
+        Favourite tea:
+        <select name='teas' tabindex='1'>
+          <option disabled='disabled' name='teas' value=''>Choose one:</option>
+          <option id='teas_ceylon' name='teas' value='ceylon'>Ceylon</option>
+          <option id='teas_breakfast' name='teas' value='breakfast'>Breakfast</option>
+          <option id='teas_earl_grey' name='teas' value='earl grey'>Earl grey</option>
+        </select>
+      </label>
+      <p>I like tea!</p>
+    </form>
+    
+You can use literals to wrap forms in divs too:
+    
+    doc = Campo.literal ".centred.form" do |wrapper|
+      wrapper << form # the form defined already above
+    end
+    
+    puts Campo.output doc
+    
+    .centred.form
+      %form{ atts[:favourite_teas], method: "POST", action: uri("/fav/teas/"), name: "favourite_teas",  }
+        %label{ for: "teas",  }
+          Favourite tea:
+          %select{ atts[:teas], tabindex: "#{i += 1}", name: "teas",  }
+            %option{  value: "", disabled: "disabled", name: "teas",  }Choose one:
+            %option{ atts[:teas_ceylon], value: "ceylon", id: "teas_ceylon", name: "teas",  }Ceylon
+            %option{ atts[:teas_breakfast], value: "breakfast", id: "teas_breakfast", name: "teas",  }Breakfast
+            %option{ atts[:teas_earl_grey], value: "earl grey", id: "teas_earl_grey", name: "teas",  }Earl grey
+        %p= "I like tea!"

data/campo.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('./lib')
+$:.unshift lib unless $:.include?(lib)
+require './lib/campo/version.rb'
+
+Gem::Specification.new do |s|
+  s.name           = "campo"
+  s.summary        = "Form builder for Haml"
+  s.description = <<-EOF
+    Form builder for Haml
+  EOF
+  s.version        = Campo::VERSION
+  s.platform       = Gem::Platform::RUBY
+  s.require_path   = "lib"
+  s.required_ruby_version    = ">= 1.9.2"
+  s.authors        = ["Iain Barnett"]
+  s.files          = `git ls-files`.split("\n")
+  s.add_dependency("haml", "~> 3.1.1")
+  s.email          = ["iainspeed @nospam@ gmail.com"]
+  s.test_files     = `git ls-files -- {test,spec,features}`.split("\n")
+  s.signing_key    = ENV['HOME'] + '/.ssh/gem-private_key.pem'
+  s.cert_chain     = [ENV['HOME'] + '/.ssh/gem-public_cert.pem']
+end

data/lib/campo.rb

@@ -0,0 +1,507 @@
+# encoding: UTF-8
+
+module Campo
+  module Childish
+    def push=( child )
+      @fields << child
+      child.parent = self
+      self
+    end
+
+    alias :<< :push=
+    
+    attr_accessor :parent
+  end # Childish
+  
+  module Iding
+    def id_tag( val )
+      val.nil? ? "" : "_#{val}"
+    end
+  end # Iding
+  
+  module Convenience
+    
+    
+    # @param [optional, Hash] attributes Any attributes you wish to add to the haml element.
+    # @example Fieldset as a block is easiest to read
+    #   form.fieldset("Your details") do |f|
+    #     f.text( "full_name",  size: 60 )
+    #     f.text( "dob", "Date of birth: ", size: 8 )
+    #   end
+    def fieldset( text, attributes={}, &block )
+      fieldset = (Fieldset.new(attributes) << Legend.new( text ))
+      block.call( fieldset ) if block
+      self << fieldset 
+      fieldset
+    end
+    
+    # @example Add a bit of code to the markup
+    #   form.bit_of_ruby( "= 5 + 1" ) }
+    def bit_of_ruby( *args )
+      tag = Campo::Haml_Ruby_Insert.new( *args )
+      self << tag
+      tag
+    end
+
+    alias :haml_ruby_insert :bit_of_ruby
+
+    # @example Output a literal string
+    #   form.literal %Q!%p= "This is a paragraph "!
+    def literal( *args )
+      tag = Campo::Literal.new( *args )
+      self << tag
+      tag
+    end
+
+    # @example 
+    #     # Select with a block of options
+    #     f.select("teas") do |s|
+    #       s.with_default
+    #       s.option("ceylon")
+    #       s.option("breakfast")
+    #       s.option("earl grey")
+    #       s.option("oolong")
+    #       s.option("sencha")
+    #     end.labelled("Favourite tea:")
+    #
+    #     # Select using chain of options
+    #     form.select("bands").option("Suede").option("Blur").option("Oasis").option("Echobelly").option("Pulp").option("Supergrass").with_default.labelled("Favourite band:")
+    #
+    # @see Select
+    def select( *args, &block )
+      select = Campo::Select.new( *args, &block )
+      self << select
+      select
+    end
+    
+    # Add an input with type of text
+    # @param [String] name The name html attribute.
+    # @param [optional, String, nil] label Give the label a name. Defaults to a capitalised name with _ replaced by spaces.
+    # @param [optional, Hash] attributes Any attributes you wish to add to the haml element.
+    # @example
+    #     f.text "full_name",  size: 60 
+    #     f.text "dob", "Date of birth: ", size: 8
+    # @return [Input] 
+    #   With the attribute `type=text`
+    def text( name, label=nil, attributes={} )
+      input( name, :text, label, attributes )
+    end
+    
+    # @param (see #text)
+    def radio( name, label=nil, attributes={} )
+      input( name, :radio, label, attributes )
+    end
+    
+    # @param (see #text)
+    def checkbox( name, label=nil, attributes={} )
+      input( name, :checkbox, label, attributes )
+    end
+    
+    
+    # @param (see #text)
+    # @param [:symbol] type The type html attribute.
+    def input( name, type, label=nil, attributes={} ) 
+      if label.kind_of? Hash
+        attributes = label
+        label = nil
+      end
+
+      field = Campo::Input.new( name, type, attributes ).labelled( label )
+      self << field
+      field
+    end
+    
+    # @param [optional,String] name
+    # @param [optional, Hash] attributes Any attributes you wish to add to the haml element.
+    def submit( name="Submit", label_inner=nil, attributes={} )
+      submit = Campo::Input.new( name, :submit, {value: name}.merge(attributes) )
+      self << submit
+      submit
+    end
+    
+    
+    def textarea( *args )
+      textarea = Campo::Textarea.new( *args )
+      self << textarea
+      textarea
+    end
+  end # Convenience
+  
+  module Helpers
+    # [ [id, lookup, selected || false], ... ]
+    def self.options_builder( name, opts )
+      return [] if opts.nil? || opts.empty?
+
+      opts.map do |opt|
+        id, lookup, selected, atts = opt
+        selected = selected ? true : false
+        atts = atts.nil? ? { } : atts
+
+        Campo::Option.new( name, id, lookup, selected, atts )
+      end
+    end
+    
+    def self.options_outputter( opts=[] )
+      return "" if opts.nil? || opts.empty?
+      opts.map{|o| "#{o.output}\n" }.reduce(:+)
+    end
+  end # Helpers
+
+  @atts = {}
+
+  class << self
+    attr_accessor :atts
+  end
+  
+  class Base 
+    include Childish
+    include Iding
+    include Convenience
+    
+    DEFAULT = { tabindex: nil }
+
+    attr_accessor :attributes, :fields
+
+    def initialize( name, attributes={}, &block )
+      @attributes = DEFAULT.merge( attributes.merge({name: name}) ).reject{|k,v| v.nil? }
+      @fields = []
+      block.call( self ) if block
+      self
+    end
+    
+    def on_output( &block )
+      @output_listener = block
+    end
+
+    def output( n=0, tab=2 )
+      @output_listener.call n, tab
+    end
+
+    def labelled( inner=nil )
+      inner ||= self.attributes[:name].gsub("_"," ").capitalize
+      parent = self.parent
+      label = Label.new( %Q!#{@attributes[:name] + id_tag(@attributes[:value]).gsub(/\W/, "_")}!, inner ) << self
+      retval = if parent.nil?
+        label
+      else
+        parent.fields.delete self
+        parent << label
+        label
+      end
+      
+      retval
+    end # labelled
+
+    def self.unhash( hash, skip=nil )
+      hash.reject{|k,v| v.nil?  }.reject{|k,v| k.to_sym == skip.to_sym unless skip.nil? }.reduce(""){|mem, (k,v)| mem + %Q!#{k}: #{Base.quotable(v)}, !}
+    end
+    
+    # if the string provided begins with a double quote but does not end in one, make it an unquoted string on output
+    # else, wrap it in quotes
+    def self.quotable( s )
+      retval = if s.respond_to?(:start_with?) && s.start_with?( %Q!"! ) &! s.end_with?( %Q!"! )
+        s[1.. -1] # chop the first character
+      else
+        %Q!"#{s}"! # wrap
+      end 
+    end
+
+
+    def self.output( top, so_far="", count=0, tab=2 )
+      so_far << "#{top.output( count, tab )}\n"
+      count += 1
+      if top.respond_to?( :fields ) && top.fields.length >= 1
+        top.fields.each do |field|
+          so_far = Base.output( field, so_far, count, tab ) 
+        end
+      end
+
+      so_far
+    end
+
+  end # Base
+  
+  # @see Convenience#literal
+  def self.literal( *args, &block )
+    Campo::Literal.new( *args, &block )
+	end
+	
+  # Pass anything but the form for the first argument to *not* have the local variable defaults added to the top
+  # @example 
+  #     Campo.output form # would add the default locals
+  #     # these won't
+  #     Campo.output :partial, input_field
+  #     Campo.output false, label
+  #     Campo.output true, fieldset
+  def self.output( *args )
+    s = <<STR
+- atts = {} if atts.nil?
+- atts.default = {} if atts.default.nil?
+- inners = {} if inners.nil?
+- inners.default = "" if inners.default.nil?
+- i = 0 # for tabindex
+
+STR
+
+
+    # default to true
+    whole_form = if args.first.kind_of? Campo::Base 
+      true
+    else 
+      args.shift
+      false
+    end
+    
+    output = Base.output( *args )
+    output = s + output if whole_form
+    output
+  end # self.output
+
+# end Campo methods
+
+
+  
+  class Form < Base
+    DEFAULT = { method: "POST" }
+
+    # @param [String] name The form's name (html) attribute.
+    # @param [optional, Hash] attributes Html attributes. They can be anything you like. Defaults follow:
+    # @option attributes [String] :method ("POST")
+    # @example
+    #     form = Campo::Form.new "example", "/path/to/post/to/" do |form|
+    #       form.text "first_field"
+    #       #... more fields follow
+    #     end
+    def initialize(name,  attributes={} )
+      super( name, DEFAULT.merge( attributes ) )
+      self.on_output do |n=0, tab=2|
+        %Q!#{" " * n * tab}%form{ atts[:#{name.gsub(/\W/, "_").downcase}], #{Base.unhash( @attributes )} }!
+      end
+      
+      self
+    end
+    
+
+  end # Form
+  
+  # Generally, the first method you'll call.
+  # @example 
+  #     # Form with a block
+  #     form = Campo.form "form1", action: "/go/for/it/" do |f|
+  #       f.text "Hello"
+  #       #... more fields follow
+  #     end
+  #
+  # @param [String] name The form's name (html) attribute.  
+  # @param [optional, Hash] attributes Html attributes. They can be anything you like. Defaults follow:
+  # @option attributes [String] :method ("POST") The method attribute for the form.
+  # @see Form#initialize
+  def self.form( name, attributes={}, &block )
+    Form.new( name, attributes, &block )
+  end
+  
+  
+  class Haml_Ruby_Insert < Base
+    def initialize( s )
+      super( nil ) # no name needed
+      @s = s.start_with?( '=' ) ? s : "= #{s}"
+    
+      self.on_output do |n=0, tab=2|
+        (" " * n * tab) + @s
+      end
+    end
+  end # Haml_Ruby_Insert
+  
+
+  # add whatever you need to with a literal
+  class Literal < Base
+    def initialize( s )
+      super( nil ) # no name needed
+      @s = s
+
+      self.on_output do |n=0, tab=2|
+        (" " * n * tab) + @s
+      end
+      self
+    end
+  end # Literal
+  
+  class Select < Base
+    def initialize( name, params={} )
+      opts = params[:opts] || []
+      attributes = params[:attributes] || {}
+      haml_insert = params[:haml_insert] || nil
+      
+      super( name, { tabindex: %q!#{i += 1}! }.merge(attributes) )
+      
+      self.on_output do |n=0, tab=2|
+        %Q!#{" " * n * tab}%select{ atts[:#{name.gsub(/\W/, "_").downcase}], #{Base.unhash( @attributes )} }! 
+      end
+      
+      self.fields += Helpers.options_builder( name, opts ) unless opts.nil? || opts.empty?
+      
+      self.fields << Haml_Ruby_Insert.new( haml_insert ) unless haml_insert.nil?
+      
+      
+      self
+    end # initialize
+      
+    # @example (see Convenience#select)  
+    def option( *args )
+      value = args.shift
+      inner = args.shift 
+      selected, attributes = *args
+      inner = value.capitalize if inner.nil?
+      self << Campo::Option.new( @attributes[:name], value, inner, selected, attributes )
+      self
+    end
+    
+    
+    # @example 
+    #     As a default:
+    #     form.select("teas").with_default.option("ceylon")
+    #     # output:
+    #       %select{ atts[:teas], tabindex: "#{i += 1}", name: "teas",  }
+    #          %option{  value: "", disabled: "disabled", name: "teas",  }Choose one:
+    #          %option{ atts[:teas_ceylon], value: "ceylon", id: "teas_ceylon", name: "teas",  }Ceylon
+    #
+    #     form.select("teas").with_default("My fave tea is:").option("ceylon")
+    #     # output:
+    #       %select{ atts[:teas], tabindex: "#{i += 1}", name: "teas",  }
+    #       %option{  value: "", disabled: "disabled", name: "teas",  }My fave tea is:
+    #       %option{ atts[:teas_ceylon], value: "ceylon", id: "teas_ceylon", name: "teas",  }Ceylon
+    def with_default( inner="Choose one:" )
+      self.fields.unshift Campo::Option.new( @attributes[:name], "", inner , nil, {disabled: "disabled" } )
+      self
+    end
+    
+    # def mark_as_selected( val )
+    #   fields.find {|field| field.value == val }.selected = {selected: "selected"}
+    # end
+  end # Select
+  
+  
+  class Option < Base
+    attr_accessor :value, :checked
+    
+    def initialize( name, value, inner=nil, selected=nil, attributes={} )
+      attributes ||= {}
+      if inner.kind_of? TrueClass
+        selected = attributes
+        inner = nil
+      end
+      
+      @inner = inner || value
+      
+      if selected.kind_of? Hash
+        attributes = selected 
+        selected = {}
+      end 
+      
+      attributes = { id: "#{(name.gsub(/\W/, "_") + id_tag(value).gsub(/\W/, "_")).downcase}" }.merge(attributes) unless value.nil? || value.to_s.empty?
+      
+      super( name, {
+        value: value,
+        selected: (selected ? "selected" : nil)
+      }.merge( attributes ) )
+      
+      atts_string = "atts[:#{@attributes[:id]}]," unless @attributes[:id].nil?
+      
+      self.on_output do |n=0, tab=2|
+        %Q!#{" " * n * tab}%option{ #{atts_string} #{Base.unhash( @attributes )} }#{@inner}!
+      end
+
+    end #initialize
+  end # Option
+  
+  
+  # form << Campo::Input.new( "submit", :submit )
+  class Input < Base  
+    
+    #{ type: nil, value: nil, name: nil }
+    #{ size: nil, maxlength: nil, type: "text" }
+    #{ size: nil, maxlength: nil, type: "hidden" }
+    #{ type: "submit" }
+    def initialize( name, type=:text, attributes={} )
+      super( name, 
+            { type: type.to_s, 
+              id: "#{name}#{id_tag(attributes[:value]).gsub(/\W/, "_")}",
+              tabindex: %q!#{i += 1}!, 
+            }.merge( attributes ) )
+            
+               
+      @attributes.delete(:name) if type == :submit
+            
+      self.on_output do |n=0, tab=2|
+        %Q!#{" " * n * tab}%input{ atts[:#{name.gsub(/\W/, "_")}#{id_tag(attributes[:value]).gsub(/\W/, "_")}], #{Base.unhash( @attributes )} }! 
+      end
+    end
+  end
+
+  class Fieldset < Base
+    
+    def initialize( attributes={} )
+      super( nil, attributes )
+      @attributes.delete(:name)
+      
+      self.on_output do |n=0, tab=2|
+        %Q!#{" " * n * tab}%fieldset{ #{Base.unhash( @attributes )} }! 
+      end
+    end # initialize
+  end # Fieldset
+  
+  
+  class Legend < Base
+    
+    def initialize( inner, attributes={} )
+      super( nil, attributes )
+      @attributes.delete(:name)
+      @inner = inner
+      
+      self.on_output do |n=0, tab=2|
+        %Q!#{" " * n * tab}%legend{ #{Base.unhash( @attributes )} }#{@inner}! 
+      end
+    end # initialize
+  end # Fieldset
+      
+
+  class Label < Base
+    
+    DEFAULT = { for: nil }
+
+    attr_reader :attributes, :fields
+
+    def initialize( name, inner=nil, attributes={} )
+      if inner.kind_of? Hash
+        attributes = inner
+        inner = nil
+      end
+      super( name, attributes )
+
+      @inner = inner
+    
+      self.on_output do |n=0, tab=2|
+        %Q!#{" " * n * tab}%label{ for: "#{@attributes[:name]}", #{Base.unhash( @attributes, :name )} }\n#{" " * (n + 1) * tab}#{@inner}! 
+      end
+    end
+
+  end # Label
+
+
+  class Textarea < Base
+    DEFAULT = { cols: 40, rows: 10, tabindex: %q!#{i += 1}! }
+
+    def initialize( name,  inner=nil, attributes={} )
+      if inner.kind_of? Hash
+        attributes = inner
+        inner = nil
+      end
+      super( name, DEFAULT.merge( attributes ) )
+      @inner = inner
+      self.on_output do |n=0, tab=2|
+        %Q!#{" " * n * tab}%textarea{ atts[:#{name.gsub(/\W/, "_")}], #{Base.unhash( @attributes )} }= inners[:#{name.gsub(/\W/, "_")}] !
+      end
+    end
+  end # Textarea
+
+end