mack 0.6.1.2 → 0.7.0

data/lib/mack/runner_helpers/request_logger.rb

@@ -17,7 +17,7 @@ module Mack
         @total_time = @end_time - @start_time
         @requests_per_second = (1 / @total_time).round
         if app_config.log.detailed_requests
-          msg = "\n\t[#{request.request_method.upcase}] '#{request.path_info}'\n"
+          msg = "\n\t[#{request.params[:method].to_s.upcase}] '#{request.path_info}'\n"
           msg << "\tSession ID: #{request.session.id}\n" if app_config.mack.use_sessions
           msg << "\tParameters: #{request.all_params}\n"
           msg << Mack::Utils::Ansi::Color.wrap(app_config.log.completed_color, "\tCompleted in #{@total_time} (#{@requests_per_second} reqs/sec) | #{response.status} [#{request.full_host}]")

data/lib/mack/runner_helpers/session.rb

@@ -7,26 +7,33 @@ module Mack
       
       def start(request, response, cookies)
         if app_config.mack.use_sessions
-          sess_id = cookies[app_config.mack.session_id]
-          unless sess_id
-            sess_id = create_new_session(request, response, cookies)
+          self.sess_id = retrieve_session_id(request, response, cookies)
+          unless self.sess_id
+            self.sess_id = create_new_session(request, response, cookies)
           else
-            sess = Cachetastic::Caches::MackSessionCache.get(sess_id)
+            sess = Cachetastic::Caches::MackSessionCache.get(self.sess_id)
             if sess
               request.session = sess
             else
               # we couldn't find it in the store, so we need to create it:
-              sess_id = create_new_session(request, response, cookies)
+              self.sess_id = create_new_session(request, response, cookies)
             end
           end
         end
       end
       
       def complete(request, response, cookies)
-        Cachetastic::Caches::MackSessionCache.set(sess_id, request.session) if app_config.mack.use_sessions
+        unless response.redirection?
+          request.session.delete(:tell)
+        end
+        Cachetastic::Caches::MackSessionCache.set(request.session.id, request.session) if app_config.mack.use_sessions
       end
       
       private
+      def retrieve_session_id(request, response, cookies)
+        cookies[app_config.mack.session_id]
+      end
+      
       def create_new_session(request, response, cookies)
         id = String.randomize(40).downcase
         cookies[app_config.mack.session_id] = {:value => id, :expires => nil}

data/lib/mack/tasks/mack_dump_tasks.rake

@@ -4,14 +4,7 @@ namespace :mack do
 
     desc "Dumps out the configuration for the specified environment."
     task :config => :environment do
-      fcs = app_config.instance.instance_variable_get("@final_configuration_settings")
-      conf = {}
-      fcs.each_pair do |k, v|
-        unless v.is_a?(Application::Configuration::Namespace)
-          conf[k.to_s] = v unless k.to_s.match("__")
-        end
-      end
-      pp conf
+      pp Mack::Configuration.dump
     end # config
     
     desc "Show all the routes available"

data/lib/mack/tasks/mack_tasks.rake

@@ -10,7 +10,7 @@ namespace :mack do
     libs = []
     libs << "-r irb/completion"
     libs << "-r #{File.join(File.dirname(__FILE__), '..', 'initialization', 'console')}"
-    exec "irb #{libs.join(" ")} --simple-prompt"
+    system "irb #{libs.join(" ")} --simple-prompt"
   end # console
   
 end # mack

data/lib/mack/tasks/test_tasks.rake

@@ -26,7 +26,7 @@ namespace :test do
     ENV["MACK_ENV"] = "test"
     Rake::Task["mack:environment"].invoke
     Rake::Task["test:setup"].invoke
-    x = `rcov test/**/*_#{app_config.mack.testing_framework == "rspec" ? "spec" : "test"}.rb -T --no-html -x Rakefile,config\/`
+    x = `rcov test/**/*_#{app_config.mack.testing_framework == "rspec" ? "spec" : "test"}.rb -T --no-html -x Rakefile,config\/,tasks\/`
     x.each do |line|
       case line
       when /^\+[\+\-]*\+$/, /^\|.*\|$/, /\d+\sLines\s+\d+\sLOC/
@@ -40,7 +40,7 @@ namespace :test do
     ENV["MACK_ENV"] = "test"
     Rake::Task["mack:environment"].invoke
     Rake::Task["test:setup"].invoke
-    `rcov test/**/*_#{app_config.mack.testing_framework == "rspec" ? "spec" : "test"}.rb -x Rakefile,config\/`
+    `rcov test/**/*_#{app_config.mack.testing_framework == "rspec" ? "spec" : "test"}.rb -x Rakefile,config\/,tasks\/`
     `open coverage/index.html`
   end
   

data/lib/mack/testing/file.rb

@@ -0,0 +1,28 @@
+require 'base64'
+module Mack
+  module Testing
+    class FileWrapper # :nodoc:
+      
+      attr_reader :path
+      attr_reader :file_name
+      attr_reader :content
+      attr_reader :size
+      attr_reader :mime
+      
+      def initialize(path)
+        @path = path
+        @file_name = File.basename(path)
+        extension = File.extname(path)
+        extension = extension.gsub!(".", "")
+        if extension and !extension.empty?
+          @mime     = Mack::Utils::MimeTypes.instance.get(extension) if extension
+        else
+          @mime     = "application/octet-stream"
+        end
+        raw_content = File.read(path)
+        @content = Base64.encode64(raw_content).strip
+        @size    = @content.size
+      end
+    end
+  end
+end

data/lib/mack/testing/helpers.rb

@@ -1,5 +1,20 @@
 require "test/unit"
 
+#--
+if Mack.env == "test"
+  module Mack
+    module RunnerHelpers # :nodoc:
+      class Session
+        private
+        def retrieve_session_id(request, response, cookies)
+          $current_session_id
+        end
+      end # Session
+    end # RunnerHelpers
+  end # Mack
+end
+#++
+
 module Mack
   module Testing # :nodoc:
     module Helpers
@@ -65,12 +80,27 @@ module Mack
     
       # Performs a 'put' request for the specified uri.
       def put(uri, options = {})
-        build_response(request.put(uri, build_request_options({:input => options.to_params})))
+        if options[:multipart]
+          form_input = build_multipart_data(options)
+          build_response(request.put(uri, build_request_options({"CONTENT_TYPE" => "multipart/form-data, boundary=Mack-boundary", "CONTENT_LENGTH" => form_input.size, :input => form_input})))
+        else
+          build_response(request.put(uri, build_request_options({:input => options.to_params})))
+        end
       end
-    
+      
+      # create a wrapper object for file upload testing.
+      def file_for_upload(path)
+        return Mack::Testing::FileWrapper.new(path)
+      end
+          
       # Performs a 'post' request for the specified uri.
       def post(uri, options = {})
-        build_response(request.post(uri, build_request_options({:input => options.to_params})))
+        if options[:multipart]
+          form_input = build_multipart_data(options)
+          build_response(request.post(uri, build_request_options({"CONTENT_TYPE" => "multipart/form-data, boundary=Mack-boundary", "CONTENT_LENGTH" => form_input.size, :input => form_input})))
+        else
+          build_response(request.post(uri, build_request_options({:input => options.to_params})))
+        end
       end
     
       # Performs a 'delete' request for the specified uri.
@@ -95,11 +125,12 @@ module Mack
     
       # Returns a Mack::Session from the request.
       def session # :nodoc:
-        Cachetastic::Caches::MackSessionCache.get(cookies[app_config.mack.session_id]) do
+        Cachetastic::Caches::MackSessionCache.get($current_session_id) do
           id = String.randomize(40).downcase
           set_cookie(app_config.mack.session_id, id)
           sess = Mack::Session.new(id)
           Cachetastic::Caches::MackSessionCache.set(id, sess)
+          $current_session_id = id
           sess
         end
       end
@@ -108,7 +139,9 @@ module Mack
       def in_session
         @_mack_in_session = true
         clear_session
+        $current_session_id = session.id
         yield
+        $current_session_id = nil
         clear_session
         @_mack_in_session = false
       end
@@ -134,6 +167,28 @@ module Mack
       end
     
       private
+      
+      def build_multipart_data(options)
+        form_input = ""
+        boundary = "--Mack-boundary\r\n"
+        options.each_pair do |k, v|
+          if v.kind_of?(Mack::Testing::FileWrapper)
+            form_input += boundary
+            form_input += "content-disposition: form-data; name=\"#{k}\"; filename=\"#{v.file_name}\"\r\n"
+            form_input += "Content-Type: #{v.mime}\r\n\r\n"
+            form_input += "#{v.content}\r\n"
+          elsif k != :multipart 
+            form_input += boundary
+            form_input += "content-disposition: form-data; name=\"#{k}\"\r\n"
+            form_input += "Content-Type: text/plain\r\n\r\n"
+            form_input += "#{v}\r\n"
+          end
+        end
+        form_input += boundary
+        return form_input
+      end
+      
+      
       def test_cookies
         @test_cookies = {} if @test_cookies.nil?
         @test_cookies

data/lib/mack/testing/rspec.rb

@@ -7,15 +7,27 @@ module Spec # :nodoc:
       include Mack::Routes::Urls
       include Mack::Testing::Helpers
     
-      alias_method :mack_spec_execute, :execute
+      alias_method :mack_run_with_description_capturing, :run_with_description_capturing
 
-      def execute(options, instance_variables)
-        in_session do
-          @__res = mack_spec_execute(options, instance_variables)
+      def run_with_description_capturing
+        begin
+            in_session do
+              instance_eval(&(@_implementation || PENDING_EXAMPLE_BLOCK))
+            end
+        ensure
+          @_matcher_description = Spec::Matchers.generated_description
+          Spec::Matchers.clear_generated_description
         end
-        @__res
       end
     
+    end # ExampleMethods
+  end # Example
+  
+  module Matchers # :nodoc:
+    def match(regexp)
+      regexp = /#{regexp}/ if regexp.is_a?(String)
+      Matchers::Match.new(regexp)
     end
-  end
-end
+  end # Matchers
+  
+end # Spec

data/lib/mack/utils/mime_types.yml

@@ -282,6 +282,7 @@
 :xls: application/excel; application/vnd.ms-excel; application/x-excel; application/x-msexcel
 :js_official: application/x-javascript
 :js: text/javascript
+:json: text/javascript
 :ani: application/x-navi-animation
 :rmp: audio/x-pn-realaudio; audio/x-pn-realaudio-plugin
 :pre: application/x-freelance

data/lib/mack/utils/server.rb

@@ -18,7 +18,7 @@ module Mack
         end
         
         # Any urls listed will go straight to the public directly and will not be served up via the app:
-        app = Rack::Static.new(app, :urls => ["/css", "/images", "/files", "/images", "/stylesheets", "/javascripts", "/media"], :root => "public")
+        app = Rack::Static.new(app, :urls => ["/css", "/images", "/files", "/images", "/stylesheets", "/javascripts", "/media", "/favicon.ico"], :root => "public")
         app = Rack::Lint.new(app) if app_config.mack.use_lint 
         app = Rack::ShowStatus.new(app) 
         app = Rack::ShowExceptions.new(app) if app_config.mack.show_exceptions

data/lib/mack/version.rb

@@ -0,0 +1,3 @@
+module Mack
+  VERSION = '0.7.0' unless const_defined?("VERSION")
+end

data/lib/mack/view_helpers/date_time_helpers.rb

@@ -0,0 +1,106 @@
+module Mack
+  module ViewHelpers # :nodoc:
+    module FormHelpers
+      
+      MONTHS = [["January", 1], ["February", 2], ["March", 3], ["April", 4], ["May", 5], ["June", 6], ["July", 7], ["August", 8], 
+                ["September", 9], ["October", 10], ["November", 11], ["December", 12]]
+      DAYS = []
+      1.upto(31) do |m| 
+        DAYS << [(m < 10 ? "0#{m}" : m), m]
+      end
+      HOURS = []
+      1.upto(24) do |h|
+        HOURS << [(h < 10 ? "0#{h}" : h), h]
+      end
+      MINUTES = []
+      1.upto(59) do |m| 
+        MINUTES << [(m < 10 ? "0#{m}" : m), m]
+      end
+      
+      # This will create a series of select boxes that compromise a time object. By default boxes will be
+      # created for day/month/year hour:minute. You can optionally turn on or off any of these boxes, including
+      # seconds by setting them to true/false. For example:
+      #   <%= date_time_select :some_time, :days => false %>
+      # will not produce a select box for days, and so on...
+      # 
+      # You can pass in an array of arrays to represent the options for any of the boxes like such:
+      #   <%= date_time_select :some_time, :day_options => [[1,"one"], [2,"two"]] %>
+      # Will produce a day select box with only two options. Alternatively you can pass in an array of values
+      # and the options will be done for you. Like such:
+      #   <%= date_time_select :some_time, :day_values => 1..60 %>
+      # Will produce a day select box with 60 options whose values and keys will be the same.
+      # 
+      # The separators for dates and times can be set with the date_separator and time_separator options. By
+      # default they are:
+      #   :date_separator => '/'
+      #   :time_separator => ':'
+      def date_time_select(name, *args)
+        var = instance_variable_get("@#{name}")
+        fe = FormElement.new(*args)
+        
+        time = var if var.is_a?(Time) || var.is_a?(Date)
+        time = var.nil? ? Time.now : (var.send(fe.calling_method) || Time.now) if time.nil?
+        
+        years = []
+        (time.year - 5).upto(time.year + 5) { |y| years << [y, y]}
+        
+        options = {:years => true, :months => true, :days => true, :hours => true, :minutes => true, :seconds => false, :year_options => years, :month_options => MONTHS, :day_options => DAYS, :hour_options => HOURS, :minute_options => MINUTES, :second_options => MINUTES, :date_separator => '/', :time_separator => ':'}.merge(fe.options)
+        
+        [:year, :month, :day, :hour, :minute, :second].each do |v|
+          if options["#{v}_values".to_sym]
+            options["#{v}_options".to_sym] = []
+            options["#{v}_values".to_sym].each {|i| options["#{v}_options".to_sym] << [i, i]}
+          end
+        end
+        
+        fe.options - [:years, :months, :days, :hours, :minutes, :seconds, :year_options, :month_options, :day_options, :hour_options, :minute_options, :second_options, :year_values, :month_values, :day_values, :hour_values, :minute_values, :second_values]
+        
+        label = label_parameter_tag(name, (fe.calling_method == :to_s ? name : "#{name}_#{fe.calling_method}"), var, fe)
+
+        
+        date_boxes = []
+        date_boxes << dt_select(:month, name, fe, time.month, options[:month_options]) if options[:months]
+        date_boxes << dt_select(:day, name, fe, time.day, options[:day_options]) if options[:days]
+        date_boxes << dt_select(:year, name, fe, time.year, options[:year_options]) if options[:years]
+        
+        time_boxes = []
+        time_boxes << dt_select(:hour, name, fe, time.hour, options[:hour_options]) if options[:hours]
+        time_boxes << dt_select(:minute, name, fe, time.min, options[:minute_options]) if options[:minutes]
+        time_boxes << dt_select(:second, name, fe, time.sec, options[:second_options]) if options[:seconds]
+        
+        boxes = date_boxes.join(options[:date_separator])
+        
+        unless time_boxes.empty?
+          boxes << " " << time_boxes.join(options[:time_separator])
+        end
+        
+        return label + boxes
+      end
+      
+      # Used just like date_time_select, but it has hours, minutes, and seconds turned off. See date_time_select
+      # for more options.
+      # 
+      #   @user = User.new
+      #   <%= :user.date_select :birth_date %>
+      #   @some_time = Time.new
+      #   <%= :date_select :some_time, :label => true %>
+      def date_select(name, *args)
+        fe = FormElement.new(*args)
+        date_time_select(name, fe.calling_method, {:hours => false, :minutes => false, :seconds => false}.merge(fe.options))
+      end
+      
+      private
+      def dt_select(col, name, fe, selected, values)
+        options = {:name => name, :id => name}
+        unless fe.calling_method == :to_s
+          options.merge!(:name => "#{name}[#{fe.calling_method}(#{col})]", :id => "#{name}_#{fe.calling_method}_#{col}")
+        else
+          options.merge!(:name => "#{name}(#{col})", :id => "#{name}_#{col}")
+        end
+        options.merge!(:options => values, :selected => selected)
+        select_tag(name, fe.options.merge(options))
+      end
+      
+    end # DateTimeHelpers
+  end # ViewHelpers
+end # Mack

data/lib/mack/view_helpers/form_helpers.rb

@@ -0,0 +1,282 @@
+module Mack
+  module ViewHelpers # :nodoc:
+    # A useful collection of helpers for forms.
+    module FormHelpers
+      
+      # Examples:
+      #   <% form(users_create_url) do -%>
+      #     # form stuff here...
+      #   <% end -%>
+      # 
+      #   <% form(users_update_url, :method => :put) do -%>
+      #     # form stuff here...
+      #   <% end -%>
+      # 
+      #   <% form(photos_create_url, :multipart => true) do -%>
+      #     # form stuff here...
+      #   <% end -%>
+      def form(action, options = {}, &block)
+        options = {:method => :post, :action => action}.merge(options)
+        if options[:id]
+          options = {:class => options[:id]}.merge(options)
+        end
+        if options[:multipart]
+          options = {:enctype => "multipart/form-data"}.merge(options)
+          options.delete(:multipart)
+        end
+        meth = nil
+        unless options[:method] == :get || options[:method] == :post
+          meth = "<input name=\"_method\" type=\"hidden\" value=\"#{options[:method]}\" />\n"
+          options[:method] = :post
+        end
+        concat("<form#{build_options(options)}>\n", block.binding)
+        concat(meth, block.binding) unless meth.blank?
+        yield
+        concat("\n</form>", block.binding)
+        # content_tag(:form, options, &block)
+      end
+      
+      # Generates a button with a form around it and will set the request method to delete.
+      def delete_button(url, value = "Delete", form_options = {}, button_options = {})
+        if button_options[:confirm]
+          button_options[:onclick] = "if (confirm('#{button_options[:confirm]}')) {submit();}; return false;"
+          button_options.delete(:confirm)
+        end
+        t = "\n" << hidden_field(:_method, :value => :delete)
+        t << "\n" << submit_button(value, button_options)
+        t << "\n"
+        content_tag(:form, {:action => url, :method => :post}.merge(form_options), t)
+      end
+      
+      alias_deprecated_method :submit_tag, :submit_button, '0.7.0'
+      
+      # Examples:
+      #   <%= submit_button %> # => <input type="submit" value="Submit" />
+      #   <%= submit_button "Login" %> # => <input type="submit" value="Login" />
+      def submit_button(value = "Submit", options = {}, *original_args)
+        # non_content_tag(:input, {:type => :submit, :value => value}.merge(options))
+        content_tag(:button, {:type => :submit}.merge(options), value)
+      end
+      
+      # Examples:
+      #   @user = User.new(:accepted_tos => true)
+      #   <%= check_box :user, :accepted_tos %> # => <input checked="checked" id="user_accepted_tos" name="user[accepted_tos]" type="checkbox" />
+      #   <%= check_box :i_dont_exist %> # => <input id="i_dont_exist" name="i_dont_exist" type="checkbox" />
+      def check_box(name, *args)
+        build_form_element(name, {:type => :checkbox}, *args) do |var, fe, options|
+          if options[:value]
+            options.merge!(:checked => "checked")
+          end
+          options.delete(:value)
+        end
+      end
+      
+      # Examples:
+      #   @user = User.new(:bio_file => "~/bio.doc")
+      #   <%= file_field :user, :bio_file %> # => <input id="user_bio_field" name="user[bio_field]" type="file" value="~/bio.doc" />
+      #   <%= file_field :i_dont_exist %> # => <input id="i_dont_exist" name="i_dont_exist" type="file" value="" />
+      def file_field(name, *args)
+        build_form_element(name, {:type => :file}, *args)
+      end
+
+      # Examples:
+      #   @user = User.new(:email => "mark@mackframework.com")
+      #   <%= hidden_field :user, :email %> # => <input id="user_email" name="user[email]" type="hidden" value="mark@mackframework.com" />
+      #   <%= hidden_field :i_dont_exist %> # => <input id="i_dont_exist" name="i_dont_exist" type="hidden" />
+      def hidden_field(name, *args)
+        build_form_element(name, {:type => :hidden}, *args)
+      end
+      
+      # Examples:
+      #   <%= image_submit "logo.png" %> # => <input src="/images/logo.png" type="image" />
+      def image_submit(src, options = {})
+        non_content_tag(:input, {:type => :image, :src => "/images/#{src}"}.merge(options))
+      end
+
+      # Examples:
+      #   @user = User.new(:level => 1)
+      #   <%= select_tag :user, :level, :options => [["one", 1], ["two", 2]] %> # => <select id="user_level" name="user[level]"><option value="1" selected>one</option><option value="2" >two</option></select>
+      #   <%= select_tag :user :level, :options => {:one => 1, :two => 2} %> # => <select id="user_level" name="user[level]"><option value="1" selected>one</option><option value="2" >two</option></select>
+      #   <%= select_tag :i_dont_exist :options => [["one", 1], ["two", 2]], :selected => 1 %> # => <select id="i_dont_exist" name="i_dont_exist"><option value="1" selected>one</option><option value="2" >two</option></select>
+      def select_tag(name, *args)
+        var = instance_variable_get("@#{name}")
+        fe = FormElement.new(*args)
+        options = {:name => name, :id => name}
+        unless fe.calling_method == :to_s
+          options.merge!(:name => "#{name}[#{fe.calling_method}]", :id => "#{name}_#{fe.calling_method}")
+        end
+
+        content = ""
+
+        opts = fe.options[:options]
+        unless opts.nil?
+          sopts = opts
+          if opts.is_a?(Array)
+          elsif opts.is_a?(Hash)
+            sopts = []
+            opts.sort.each do |k,v|
+              sopts << [k, v]
+            end
+          else
+            raise ArgumentError.new(":options must be either an Array of Arrays or a Hash!")
+          end
+          sel_value = var.send(fe.calling_method) if var
+          sel_value = fe.options[:selected] if fe.options[:selected]
+          sopts.each do |kv|
+            selected = kv[1].to_s == sel_value.to_s ? "selected" : ""
+            content << %{\n<option value="#{kv[1]}" #{selected}>#{kv[0]}</option>}
+          end
+          fe.options.delete(:selected)
+          fe.options.delete(:options)
+        end
+        
+        return label_parameter_tag(name, options[:id], var, fe) + content_tag(:select, options.merge(fe.options), content)
+      end
+      
+      # Examples:
+      #   @user = User.new(:bio => "my bio here")
+      #   <%= text_area :user, :bio %> # => <textarea id="user_bio" name="user[bio]">my bio here</textarea>
+      #   <%= text_area :i_dont_exist %> # => <textarea id="i_dont_exist" name="i_dont_exist"></textarea>
+      #   <%= text_area :i_dont_exist :value => "hi there" %> # => <textarea id="i_dont_exist" name="i_dont_exist">hi there</textarea>
+      def text_area(name, *args)
+        var = instance_variable_get("@#{name}")
+        fe = FormElement.new(*args)
+        options = {:name => name, :id => name, :cols => 60, :rows => 20}
+        if var.nil?
+          value = fe.options[:value]
+          fe.options.delete(:value)
+          return label_parameter_tag(name, options[:id], var, fe) + content_tag(:textarea, options.merge(fe.options), value)
+        else
+          unless fe.calling_method == :to_s
+            options.merge!(:name => "#{name}[#{fe.calling_method}]", :id => "#{name}_#{fe.calling_method}")
+          end
+          options[:value] = var.send(fe.calling_method)
+          
+          yield var, fe, options if block_given?
+          
+          content = options[:value]
+          options.delete(:value)
+          
+          return label_parameter_tag(name, options[:id], var, fe) + content_tag(:textarea, options.merge(fe.options), content)
+        end
+      end
+      
+      # Examples:
+      #   @user = User.new(:email => "mark@mackframework.com")
+      #   <%= text_field :user, :email %> # => <input id="user_email" name="user[email]" type="text" value="mark@mackframework.com" />
+      #   <%= text_field :i_dont_exist %> # => <input id="i_dont_exist" name="i_dont_exist" type="text" />
+      def text_field(name, *args)
+        build_form_element(name, {:type => :text}, *args)
+      end
+      
+      # Examples:
+      #   @user = User.new(:email => "mark@mackframework.com")
+      #   <%= password_field :user, :email %> # => <input id="user_email" name="user[email]" type="password" value="mark@mackframework.com" />
+      #   <%= password_field :i_dont_exist %> # => <input id="i_dont_exist" name="i_dont_exist" type="password" />
+      def password_field(name, *args)
+        build_form_element(name, {:type => :password}, *args)
+      end
+      
+      # Examples:
+      #   @user = User.new(:level => 1)
+      #   <%= radio_button :user, :level %> # => <input checked="checked" id="user_level" name="user[level]" type="radio" value="1" />
+      #   <%= radio_button :user, :level, :value => 2 %> # => <input id="user_level" name="user[level]" type="radio" value="2" />
+      #   <%= radio_button :i_dont_exist %> # => <input id="i_dont_exist" name="i_dont_exist" type="radio" value="" />
+      def radio_button(name, *args)
+        build_form_element(name, {:type => :radio, :value => ""}, *args) do |var, fe, options|
+          if fe.options[:value]
+            if fe.options[:value] == options[:value]
+              options.merge!(:checked => "checked")
+            end
+          elsif options[:value]
+            options.merge!(:checked => "checked")
+          end
+        end
+      end
+      
+      # Examples:
+      #   @user = User.new
+      #   <%= label_tag :user, :email %> # => <label for="user_email">Email</label>
+      #   <%= label_tag :i_dont_exist %> # => <label for="i_dont_exist">I don't exist</label>
+      #   <%= label_tag :i_dont_exist, :value => "Hello" %> # => <label for="i_dont_exist">Hello</label>
+      def label_tag(name, *args)
+        fe = FormElement.new(*args)
+        unless fe.options[:for]
+          fe.options[:for] = (fe.calling_method == :to_s ? name.to_s : "#{name}_#{fe.calling_method}")
+        end
+        unless fe.options[:value]
+          fe.options[:value] = (fe.calling_method == :to_s ? name.to_s.humanize : fe.calling_method.to_s.humanize)
+        end
+        content = fe.options[:value]
+        fe.options.delete(:value)
+        content_tag(:label, fe.options, content)
+      end
+      
+      private
+      def label_parameter_tag(name, id, var, fe)
+        label = ""
+        if fe.options[:label]
+          if fe.options[:label].is_a?(TrueClass)
+            if var.nil?
+              label = %{<label for="#{id}">#{name.to_s.humanize}</label>}
+            else
+              label = %{<label for="#{id}">#{fe.calling_method.to_s.humanize}</label>}
+            end
+          else
+            label = %{<label for="#{id}">#{fe.options[:label]}</label>}
+          end
+          fe.options.delete(:label)
+        end
+        return label
+      end
+      
+      def build_form_element(name, options, *original_args) # :nodoc:
+        var = instance_variable_get("@#{name}")
+        fe = FormElement.new(*original_args)
+        options = {:name => name, :id => name}.merge(options)
+        if var.nil?
+          return label_parameter_tag(name, options[:id], var, fe) + non_content_tag(:input, options.merge(fe.options))
+        else
+          unless fe.calling_method == :to_s
+            options.merge!(:name => "#{name}[#{fe.calling_method}]", :id => "#{name}_#{fe.calling_method}")
+          end
+          options[:value] = var.send(fe.calling_method)
+          
+          yield var, fe, options if block_given?
+          
+          return label_parameter_tag(name, options[:id], var, fe) + non_content_tag(:input, options.merge(fe.options))
+        end
+      end
+      
+      class FormElement # :nodoc:
+
+        attr_accessor :calling_method
+        attr_accessor :options
+
+        def initialize(*args)
+          args = args.parse_splat_args
+          self.calling_method = :to_s
+          self.options = {}
+          case args
+          when Symbol, String
+            self.calling_method = args
+          when Hash
+            self.options = args
+          when Array
+            self.calling_method = args[0]
+            self.options = args[1]
+          when nil
+          else
+            raise ArgumentError.new("You must provide either a Symbol, a String, a Hash, or a combination thereof.")
+          end
+          if self.options[:checked]
+            self.options[:checked] = :checked
+          end
+        end
+
+      end
+      
+      
+    end # FormHelpers
+  end # ViewHelpers
+end # Mack