zen 0.2.7 → 0.2.8

data/lib/zen/helper/acl.rb

@@ -3,19 +3,21 @@ module Ramaze
   #:nodoc:
   module Helper
     ##
-    # This helper provides an easy way of working with the ACL system that ships with Zen. 
-    # Using this helper you can restrict access to methods, view elements and pretty much 
-    # everything else based on the user's permissions.
+    # This helper provides an easy way of working with the ACL system that ships
+    # with Zen. Using this helper you can restrict access to methods, view
+    # elements and pretty much everything else based on the user's permissions.
     #
-    # In order to restrict certain actions to only those with the correct permissions you
-    # can use the method "user_authorized?". This method takes a list of required 
-    # permissions and when the user has the correct permissions it will return true:
+    # In order to restrict certain actions to only those with the correct
+    # permissions you can use the method "user_authorized?". This method takes
+    # a list of required permissions and when the user has the correct
+    # permissions it will return true:
     #
     #     user_authorized?([:read]) # => true
     #
-    # The method has 3 parameters: a list of permissions, a boolean that indicates whether
-    # all of them or just a single one is required and a third argument that can be used
-    # to manually specify the controller to validate against rather than the current node.
+    # The method has 3 parameters: a list of permissions, a boolean that
+    # indicates whether all of them or just a single one is required and a third
+    # argument that can be used to manually specify the controller to validate
+    # against rather than the current node.
     #
     #     user_authorized?([:read], true 'FoobarController')
     #
@@ -24,34 +26,42 @@ module Ramaze
     # @see    Users::Controller::AccessRules()
     #
     module ACL
-
       ##
-      # Builds a hash containing the permissions for all controllers. First all group
-      # based rules will be retrieved. If the user is in a super group he'll gain full
-      # access. However, if there's a user specific rule it will overwrite the rules set
-      # for the group. This means that if a group allows something but a user rule doesn't
-      # the user won't be able to gain access to the resource.
+      # Builds a hash containing the permissions for all controllers. First all
+      # group based rules will be retrieved. If the user is in a super group
+      # he'll gain full access. However, if there's a user specific rule it will
+      # overwrite the rules set for the group. This means that if a group allows
+      # something but a user rule doesn't the user won't be able to gain access
+      # to the resource.
       #
       # @author Yorick Peterse
       # @since  0.1
       # @return [Hash]
       #
       def extension_permissions
-        if session[:access_rules]
-          return session[:access_rules]
-        end
+        return session[:access_rules] if session[:access_rules]
 
         user            = session[:user]
         user_groups     = user.user_groups
-        @used_rules     = {}
-        available_rules = [:create_access, :read_access, :update_access, :delete_access]
+        @__used_rules   = {}
+        available_rules = [
+          :create_access,
+          :read_access,
+          :update_access,
+          :delete_access
+        ]
 
         # First all group rules should be built
         user_groups.each do |group|
           # If it's a super group we'll add all rules
           if group.super_group === true
             ::Zen::Package::Controllers.each do |controller|
-              @used_rules[controller.to_s] = [:create, :read, :update, :delete]
+              @__used_rules[controller.to_s] = [
+                :create,
+                :read,
+                :update,
+                :delete
+              ]
             end
           end
 
@@ -65,38 +75,34 @@ module Ramaze
           process_permissions(rule, available_rules)
         end
 
-        # Store the rules in the user's session so that they don't have to be re-processed
-        # every time this method is called.
-        session[:access_rules] = @used_rules
+        # Store the rules in the user's session so that they don't have to be
+        # re-processed every time this method is called.
+        session[:access_rules] = @__used_rules
 
-        return @used_rules
+        return @__used_rules
       end
-      
+
       ##
-      # Checks if the user has the specified permissions for the current extension that 
-      # was called. Returns true if this is the case and false otherwise.
+      # Checks if the user has the specified permissions for the current
+      # extension that was called. Returns true if this is the case and false
+      # otherwise.
       #
       # @author Yorick Peterse
       # @param  [Array] required Array of permissions that are required.
-      # @param  [Boolean] require_all Boolean that specifies that the user should have 
-      # ALL specified permissios. Setting this to false causes this method to return true 
-      # if any of the permissions are set for the current user.
-      # @param  [String] controller When set this will overwrite the controller name of
-      # action.node. This is useful when you want to check the permissions of a different
-      # controller than the current one.
-      # @return [TrueClass]
+      # @param  [Boolean] require_all Boolean that specifies that the user
+      # should have ALL specified permissios. Setting this to false causes this
+      # method to return true if any of the permissions are set for the current
+      # user.
+      # @param  [String] controller When set this will overwrite the controller
+      # name of action.node. This is useful when you want to check the
+      # permissions of a different controller than the current one.
+      # @return [TrueClass/FalseClass]
       #
       def user_authorized?(required, require_all = true, controller = nil)
-        # Get the ACL list
-        rules = extension_permissions
+        rules      = extension_permissions
+        controller = action.node.to_s if !controller
 
-        if !controller
-          controller = action.node.to_s
-        end
-
-        if !rules.key?(controller)
-          return false
-        end
+        return false if !rules.key?(controller)
 
         required.each do |req|
           if require_all === false and rules[controller].include?(req)
@@ -112,12 +118,12 @@ module Ramaze
       private
 
       ##
-      # Extracts and stores all the permissions from a given rule. 
+      # Extracts and stores all the permissions from a given rule.
       #
       # @author Yorick Peterse
       # @since  0.2.5
-      # @param  [Users::Model::AccessRule] rule Database record containing the details of
-      # a single rule.
+      # @param  [Users::Model::AccessRule] rule Database record containing the
+      # details of a single rule.
       # @param  [Array] available_rules All the available rules that can be used.
       #
       def process_permissions(rule, available_rules)
@@ -145,18 +151,32 @@ module Ramaze
 
           # Add the rules for all the controllers
           controllers.each do |c|
-            @used_rules[c] ||= []
+            @__used_rules[c] ||= []
 
-            if method === :push and @used_rules[c].include?(available_rule)
+            if method === :push and @__used_rules[c].include?(available_rule)
               next
             end
 
             # Add or remove the permission
-            @used_rules[c].send(method, available_rule)
+            @__used_rules[c].send(method, available_rule)
           end
         end
       end
 
-    end
-  end
-end
+      ##
+      # Method that checks if the user has the given permissions. If this isn't
+      # the case an error message is displayed and the user won't be able to
+      # access the page.
+      #
+      # @author Yorick Peterse
+      # @since  0.2.8
+      # @param  [Array] *args An array of permissions that are required.
+      #
+      def require_permissions(*args)
+        if !user_authorized?(args)
+          respond(lang('zen_general.errors.not_authorized'), 403)
+        end
+      end
+    end # ACL
+  end # Helper
+end # Ramaze

data/lib/zen/helper/blue_form_vendor.rb

@@ -0,0 +1,689 @@
+require 'ramaze'
+require 'ramaze/gestalt'
+
+module Ramaze
+  module Helper
+    ##
+    # == Introduction
+    #
+    # The BlueForm helper tries to be an even better way to build forms
+    # programmatically.  By using a simple block you can quickly create all the
+    # required elements for your form.
+    #
+    # Since November 2010 the BlueForm helper works different. You can now
+    # specify an object as the first parameter of the form_for() method. This
+    # object will be used to retrieve the values of each field. This means that
+    # you can directly pass a database result object to the form and no longer
+    # have to manually specify values. However, you can still specify your own
+    # values if you want.
+    #
+    # Old behaviour:
+    #
+    #  form_for(:method => :post) do |f|
+    #    f.input_text 'Username', :username, 'Chuck Norris'
+    #  end
+    #
+    # New behaviour:
+    #
+    #  # @data is an object that contains an instance variable named "username".
+    #  # This variable contains the value "Chuck Norris".
+    #  form_for(@data, :method => :post) do |f|
+    #    f.input_text 'Username', :username
+    #  end
+    #
+    # == Form Data
+    #
+    # As stated earlier it's possible to pass an object to the form_for()
+    # method. What kind of object this is, a database result object or an
+    # OpenStruct object doesn't matter as long as the attributes can be accessed
+    # outside of the object (this can be done using attr_readers). This makes it
+    # extremely easy to directly pass a result object from your favourite ORM.
+    # Example:
+    #
+    #  @data = User[1]
+    #
+    #  form_for(@data, :method => :post) do |f|
+    #    f.input_text 'Username', :username
+    #  end
+    #
+    # If you don't want to use an object you can simply set the first parameter
+    # to nil.
+    #
+    # == HTML Output
+    #
+    # The form helper uses Gestalt, Ramaze's custom HTML builder that works
+    # somewhat like Erector. The output is very minimalistic, elements such as
+    # legends and fieldsets have to be added manually. Each combination of a
+    # label and input element will be wrapped in <p> tags.
+    #
+    # When using the form helper as a block in your templates it's important to
+    # remember that the result is returned and not displayed in the browser
+    # directly. When using Etanni this would result in something like the
+    # following:
+    #
+    #  #{
+    #    form_for(@result, :method => :post) do |f| do
+    #      f.input_text 'Text label', :textname, 'Chunky bacon!'
+    #    end
+    #  }
+    #
+    # @example
+    #
+    #  form_for(@data, :method => :post) do |f|
+    #    f.input_text 'Username', :username
+    #  end
+    #
+    module BlueFormVendor
+      ##
+      # The form method generates the basic structure of the form. It should be
+      # called using a block and it's return value should be manually sent to
+      # the browser (since it does not echo the value).
+      #
+      # @param [Object] form_values Object containing the values for each form
+      #  field.
+      # @param [Hash] options Hash containing any additional form attributes
+      #  such as the method, action, enctype and so on.
+      # @param [Block] block Block containing the elements of the form such as
+      #  password fields, textareas and so on.
+      #
+      def form_for(form_values, options = {}, &block)
+        form = Form.new(form_values, options)
+        form.build(form_errors, &block)
+        form
+      end
+
+      ##
+      # Manually add a new error to the form_errors key in the flash hash. The
+      # first parameter is the name of the form field and the second parameter
+      # is the custom message.
+      #
+      # @param [String] name The name of the form field to which the error
+      #  belongs.
+      # @param [String] message The custom error message to show.
+      #
+      def form_error(name, message)
+        if respond_to?(:flash)
+          old = flash[:form_errors] || {}
+          flash[:form_errors] = old.merge(name.to_s => message.to_s)
+        else
+          form_errors[name.to_s] = message.to_s
+        end
+      end
+
+      ##
+      # Returns the hash containing all existing errors and allows other methods
+      # to set new errors by using this method as if it were a hash.
+      #
+      # @return [Array] All form errors.
+      #
+      def form_errors
+        if respond_to?(:flash)
+          flash[:form_errors] ||= {}
+        else
+          @form_errors ||= {}
+        end
+      end
+
+      ##
+      # Retrieve all the form errors for the specified model and add them to the
+      # flash hash.
+      #
+      # @param [Object] obj An object of a model that contains form errors.
+      #
+      def form_errors_from_model(obj)
+        if obj.respond_to?(:errors)
+          obj.errors.each do |key, value|
+            if value.respond_to?(:first)
+              value = value.first
+            end
+
+            form_error(key.to_s, value % key)
+          end
+        end
+      end
+
+      ##
+      # Main form class that contains all the required methods to generate form
+      # specific tags, such as textareas and select boxes. Do note that this
+      # class is not thread-safe so you should modify it only within one thread
+      # of execution.
+      #
+      class Form
+        attr_reader :g
+        attr_reader :form_values
+
+        ##
+        # Constructor method that generates an instance of the Form class.
+        #
+        # @param [Object] form_values Object containing the values for each form
+        #  field.
+        # @param [Hash] options A hash containing any additional form attributes.
+        # @return [Object] An instance of the Form class.
+        #
+        def initialize(form_values, options)
+          @form_values  = form_values
+          @form_args    = options.dup
+          @g            = Gestalt.new
+        end
+
+        ##
+        # Builds the form by generating the opening/closing tags and executing
+        # the methods in the block.
+        #
+        # @param [Hash] form_errors Hash containing all form errors (if any).
+        #
+        def build(form_errors = {})
+          # Convert all the keys in form_errors to strings and
+          # retrieve the correct values in case
+          @form_errors = {}
+
+          form_errors.each do |key, value|
+            if value.respond_to?(:first)
+              value = value.first
+            end
+
+            @form_errors[key.to_s] = value
+          end
+
+          @g.form(@form_args) do
+            if block_given?
+              yield self
+            end
+          end
+        end
+
+        ##
+        # Generate a <legend> tag.
+        #
+        # @param [String] text The text to display inside the legend tag.
+        # @example
+        #
+        #   form_for(@data, :method => :post) do |f|
+        #     f.legend 'Ramaze rocks!'
+        #   end
+        #
+        def legend(text)
+          @g.legend(text)
+        end
+
+        ##
+        # Generate a fieldset tag.
+        #
+        # @param [Block] &block The form elements to display inside the fieldset.
+        # @example
+        #
+        #  form_for(@data, :method => :post) do |f|
+        #    f.fieldset do
+        #      f.legend 'Hello, world!'
+        #    end
+        #  end
+        #
+        def fieldset(&block)
+          @g.fieldset(&block)
+        end
+
+        ##
+        # Generate an input tag with a type of "text" along with a label tag.
+        # This method also has the alias "text" so feel free to use that one
+        # instead of input_text.
+        #
+        # @param [String] label The text to display inside the label tag.
+        # @param [String Symbol] name The name of the text field.
+        # @param [Hash] args Any additional HTML attributes along with their
+        #  values.
+        # @example
+        #
+        #   form_for(@data, :method => :post) do |f|
+        #     f.input_text 'Username', :username
+        #   end
+        #
+        def input_text(label, name, args = {})
+          # The ID can come from 2 places, id_for and the args hash
+          id   = args[:id] ? args[:id] : id_for(name)
+          args = args.merge(:type => :text, :name => name, :id => id)
+
+          if !args[:value] and @form_values.respond_to?(name)
+            args[:value] = @form_values.send(name)
+          end
+
+          @g.p do
+            label_for(id, label, name)
+            @g.input(args)
+          end
+        end
+        alias text input_text
+
+        ##
+        # Generate an input tag with a type of "password" along with a label.
+        # Password fields are pretty much the same as text fields except that
+        # the content of these fields is replaced with dots. This method has the
+        # following alias: "password".
+        #
+        # @param [String] label The text to display inside the label tag.
+        # @param [String Symbol] name The name of the password field.
+        # @param [Hash] args Any additional HTML attributes along with their
+        #  values.
+        # @example
+        #
+        #  form_for(@data, :method => :post) do |f|
+        #    f.input_password 'My password', :password
+        #  end
+        #
+        def input_password(label, name, args = {})
+          # The ID can come from 2 places, id_for and the args hash
+          id   = args[:id] ? args[:id] : id_for(name)
+          args = args.merge(:type => :password, :name => name, :id => id)
+
+          if !args[:value] and @form_values.respond_to?(name)
+            args[:value] = @form_values.send(name)
+          end
+
+          @g.p do
+            label_for(id, label, name)
+            @g.input(args)
+          end
+        end
+        alias password input_password
+
+        ##
+        # Generate a submit tag (without a label). A submit tag is a button that
+        # once it's clicked will send the form data to the server.
+        #
+        # @param [String] value The text to display in the button.
+        # @param [Hash] args Any additional HTML attributes along with their
+        #  values.
+        # @example
+        #
+        #  form_for(@data, :method => :post) do |f|
+        #    f.input_submit 'Save'
+        #  end
+        #
+        def input_submit(value = nil, args = {})
+          args         = args.merge(:type => :submit)
+          args[:value] = value unless value.nil?
+
+          @g.p do
+            @g.input(args)
+          end
+        end
+        alias submit input_submit
+
+        ##
+        # Generate an input tag with a type of "checkbox".
+        #
+        # If you want to have multiple checkboxes you can either use an array or
+        # a hash.  In the case of an array the values will also be used as text
+        # for each checkbox.  When using a hash the key will be displayed and
+        # the value will be the value of the checkbox. Example:
+        #
+        #  @data = Class.new
+        #    attr_reader :gender_arr
+        #    attr_reader :gender_hash
+        #
+        #    def initialize
+        #      @gender_arr  = ['male', 'female']
+        #      @gender_hash = {"Male" => "male", "Female" => "female"}
+        #    end
+        #  end.new
+        #
+        #  form_for(@data, :method => :post) do |f|
+        #    f.input_checkbox "Gender", :gender_arr
+        #    f.input_checkbox "Gender", :gender_hash
+        #  end
+        #
+        # @example
+        #  form_for(@data, :method => :post) do |f|
+        #    f.input_checkbox 'Remember me', :remember_user
+        #  end
+        #
+        # @param [String] label The text to display inside the label tag.
+        # @param [String Symbol] name The name of the checkbox.
+        # @param [String/Array] checked String or array that indicates which
+        #  value(s) should be checked.
+        # @param [Hash] args Any additional HTML attributes along with their
+        #  values.
+        # @option args [String/Symbol] :id The value to use for the ID attribute.
+        # @option args [Array] :values An array containing the possible values
+        #  for the checkboxes.
+        # @option args [String/Symbol] :span_class The class to use for the
+        #  <span> element that's wrapped around the checkbox.
+        # @option args [TrueClass/FalseClass] :show_value When set to false the
+        #  value of each checkbox won't be displayed to the right of the
+        #  checkbox. This option is set to true by default.
+        # @option args [TrueClass/FalseClass] :show_label When set to true
+        #  (default) the label for the checkbox will be displayed. Setting this
+        #  to false will hide it.
+        #
+        def input_checkbox(label, name, checked = nil, args = {})
+          id = args[:id] ? args[:id] : "#{id_for(name)}_0"
+
+          # Determine whether or not to show the value of the checkbox
+          if args.key?(:show_value)
+            show_value = args.delete(:show_value)
+          else
+            show_value = true
+          end
+
+          # Determine whether or not to show the label
+          if args.key?(:show_label)
+            show_label = args.delete(:show_label)
+          else
+            show_label = true
+          end
+
+          # Get the checkbox value from either the args hash or from
+          # the form object (as specified in the form_for() method).
+          if !args[:values] and @form_values.respond_to?(name)
+            args[:values] = @form_values.send(name)
+          end
+
+          # That class for each element wrapper (a span tag) can be customized
+          # using :span_class => "a_class".
+          if args[:span_class]
+            span_class = args[:span_class]
+            args.delete(:span_class)
+          else
+            span_class = "checkbox_wrap"
+          end
+
+          # Get the type from the args hash instead of pre-defining it. Doing so
+          # means we can use this method for the input_radio method.
+          args[:type] = :checkbox if !args[:type]
+
+          # Convert the values to an array if it's something we can't use in a loop
+          # (e.g. a string).
+          if args[:values].class != Hash and args[:values].class != Array
+            args[:values] = [args[:values]]
+          end
+
+          # Create a checkbox for each value
+          if !args[:values].empty?
+            @g.p do
+              # Let's create the label and the hidden field
+              if show_label === true
+                label_for(id, label, name)
+              end
+
+              # Loop through all the values. Each checkbox will have an ID of
+              # "form-NAME-INDEX". Each name will be NAME followed by [] to
+              # indicate it's an array (since multiple values are possible).
+              args[:values].each_with_index do |value, index|
+                id = args[:id] ? args[:id] : "#{id_for(name)}_#{index}"
+
+                if args[:type] == :checkbox
+                  checkbox_name = "#{name}[]"
+                else
+                  checkbox_name = name
+                end
+
+                # Copy all additional attributes and their values except the
+                # values array.
+                opts = args.clone
+                opts.delete(:values)
+
+                # Get the value and text to display for each checkbox
+                if value.class == Array
+                  checkbox_text  = value[0]
+                  checkbox_value = value[1]
+                else
+                  checkbox_text = checkbox_value = value
+                end
+
+                # Let's see if the current item is checked
+                if checked.class == Array
+                  if checked.include?(checkbox_value)
+                    opts[:checked] = 'checked'
+                  end
+                else
+                  if checkbox_value == checked
+                    opts[:checked] = 'checked'
+                  end
+                end
+
+                # And we're done, easy wasn't it?
+                opts = opts.merge(
+                  :name => checkbox_name, :id => id, :value => checkbox_value
+                )
+
+                # Generate the following HTML:
+                #
+                # <span class="#{span_class}">
+                #   <input type="checkbox" name="#{checkbox_name}" id="#{id}"
+                #   value="#{value}" /> #{value}
+                # </span>
+                #
+                @g.span(:class => span_class) do
+                  @g.input(opts)
+                  " #{checkbox_text}" if show_value === true
+                end
+              end
+            end
+          end
+        end
+        alias checkbox input_checkbox
+
+        ##
+        # Generate an input tag with a type of "radio".
+        #
+        # If you want to generate multiple radio buttons you can use an array
+        # just like you can with checkboxes. Example:
+        #
+        #  @data = Class.new
+        #    attr_reader :gender_arr
+        #    attr_reader :gender_hash
+        #
+        #    def initialize
+        #      @gender_arr  = ['male', 'female']
+        #      @gender_hash = {"Male" => "male", "Female" => "female"}
+        #    end
+        #  end.new
+        #
+        #  form_for(@data, :method => :post) do |f|
+        #    f.input_radio "Gender", :gender_arr
+        #    f.input_radio "Gender", :gender_hash
+        #  end
+        #
+        # For more information see the input_checkbox() method.
+        #
+        # @param [String] label The text to display inside the label tag.
+        # @param [String Symbol] name The name of the radio button.
+        # @param [String] checked String that indicates if (and which) radio
+        #  button should be checked.
+        # @param [Hash] args Any additional HTML attributes along with their
+        #  values.
+        # @see input_checkbox()
+        # @example
+        #  form_for(@data, :method => :post) do |f|
+        #    f.input_radio 'Gender', :gender
+        #  end
+        #
+        def input_radio(label, name, checked = nil, args = {})
+          # Force a type of "radio"
+          args[:type] = :radio
+
+          if !args[:span_class]
+            args[:span_class] = "radio_wrap"
+          end
+
+          self.input_checkbox(label, name, checked, args)
+        end
+        alias radio input_radio
+
+        ##
+        # Generate a field for uploading files.
+        #
+        # @param [String] label The text to display inside the label tag.
+        # @param [String Symbol] name The name of the radio tag.
+        # @param [Hash] args Any additional HTML attributes along with their
+        #  values.
+        # @example
+        #
+        #  form_for(@data, :method => :post) do |f|
+        #    f.input_file 'Image', :image
+        #  end
+        #
+        def input_file(label, name, args = {})
+          id   = args[:id] ? args[:id] : id_for(name)
+          args = args.merge(:type => :file, :name => name, :id => id)
+
+          @g.p do
+            label_for(id, label, name)
+            @g.input(args)
+          end
+        end
+        alias file input_file
+
+        ##
+        # Generate a hidden field. Hidden fields are essentially the same as
+        # text fields except that they aren't displayed in the browser.
+        #
+        # @param [String Symbol] name The name of the hidden field tag.
+        # @param [String] value The value of the hidden field
+        # @param [Hash] args Any additional HTML attributes along with their
+        #  values.
+        # @example
+        #
+        #  form_for(@data, :method => :post) do |f|
+        #    f.input_hidden :user_id
+        #  end
+        #
+        def input_hidden(name, value = nil, args = {})
+          args = args.merge(:type => :hidden, :name => name)
+
+          if !value and @form_values.respond_to?(name)
+            args[:value] = @form_values.send(name)
+          else
+            args[:value] = value
+          end
+
+          @g.input(args)
+        end
+        alias hidden input_hidden
+
+        ##
+        # Generate a text area.
+        #
+        # @param [String] label The text to display inside the label tag.
+        # @param [String Symbol] name The name of the textarea.
+        # @param [Hash] args Any additional HTML attributes along with their
+        #  values.
+        # @example
+        #
+        #  form_for(@data, :method => :post) do |f|
+        #    f.textarea 'Description', :description
+        #  end
+        #
+        def textarea(label, name, args = {})
+          id = args[:id] ? args[:id] : id_for(name)
+
+          # Get the value of the textarea
+          if !args[:value] and @form_values.respond_to?(name)
+            value = @form_values.send(name)
+          else
+            value = args[:value]
+            args.delete(:value)
+          end
+
+          args = args.merge(:name => name, :id => id)
+
+          @g.p do
+            label_for(id, label, name)
+            @g.textarea(args){ value }
+          end
+        end
+
+        ##
+        # Generate a select tag along with the option tags and a label.
+        #
+        # @param [String] label The text to display inside the label tag.
+        # @param [String Symbol] name The name of the select tag.
+        # @param [Hash] args Hash containing additional HTML attributes.
+        # @example
+        #
+        #  form_for(@data, :method => :post) do |f|
+        #    f.select 'Country', :country_list
+        #  end
+        #
+        def select(label, name, args = {})
+          id              = args[:id] ? args[:id] : id_for(name)
+          multiple, size  = args.values_at(:multiple, :size)
+
+          # Get all the values
+          if !args[:values] and @form_values.respond_to?(name)
+            values = @form_values.send(name)
+          else
+            values = args[:values]
+            args.delete(:values)
+          end
+
+          args[:multiple] = 'multiple' if multiple
+          args[:size]     = (size || values.count || 1).to_i
+          args[:name]     = multiple ? "#{name}[]" : name
+          args            = args.merge(:id => id)
+
+          # Retrieve the selected value
+          has_selected, selected = args.key?(:selected), args[:selected]
+                        selected = [selected] if !selected.is_a?(Array)
+          args.delete(:selected)
+
+          @g.p do
+            label_for(id, label, name)
+            @g.select args do
+              values.each do |value, o_name|
+                o_name ||= value
+                o_args = {:value => value}
+
+                if has_selected and selected.include?(value)
+                  o_args[:selected] = 'selected'
+                end
+
+                @g.option(o_args){ o_name }
+              end
+            end
+          end
+        end
+
+        ##
+        # Method used for converting the results of the BlueForm helper to a
+        # string
+        #
+        # @return [String] The form output
+        #
+        def to_s
+          @g.to_s
+        end
+
+        private
+
+        ##
+        # Generate a label based on the id and value.
+        #
+        # @param [String] id The ID to which the label belongs.
+        # @param [String] value The text to display inside the label tag.
+        # @param [String] name The name of the field to which the label belongs.
+        #
+        def label_for(id, value, name)
+          if error = @form_errors.delete(name.to_s)
+            @g.label("#{value} ", :for => id){ @g.span(:class => :error){ error } }
+          else
+            @g.label(value, :for => id)
+          end
+        end
+
+        ##
+        # Generate a value for an ID tag based on the field's name.
+        #
+        # @param  [String] field_name The name of the field.
+        # @return [String] The ID for the specified field name.
+        #
+        def id_for(field_name)
+          if name = @form_args[:name]
+            "#{name}_#{field_name}".downcase.gsub(/-/, '_')
+          else
+            "form_#{field_name}".downcase.gsub(/-/, '_')
+          end
+        end
+      end # Form
+    end # BlueForm
+  end # Helper
+end # Ramaze