Method: Dao::Form::Elements#select

Defined in:

lib/dao/form.rb

#select(*args, &block) ⇒ Object

# File 'lib/dao/form.rb', line 369

def select(*args, &block)
  options = args.extract_options!.to_options! 
  keys = scope(args)

  name = options.delete(:name) || name_for(keys)
  values = options.delete(:values) || options.delete(:options) || options.delete(:from)

  has_blank = options.has_key?(:blank) && options[:blank] != false
  blank = options.delete(:blank)

  id = options.delete(:id) || id_for(keys)
  klass = class_for(keys, options.delete(:class))
  error = error_for(keys, options.delete(:error))

  if values.nil?
    key = keys.map{|key| "#{ key }"}
    key.last << "_options"
    values = attributes.get(*key) if attributes.has?(*key)
  end

  if options[:multiple]
    name += '[]'
  end

  list = Array(values).map{|value| value.dup rescue value} # ensure list is dup'd

  case list.first
    when Hash, Array
      nil
    else
      list.flatten!
      list.compact!
      list.map!{|element| [element, element]}
  end

  if has_blank
    case blank
      when false
        blank = nil
      when nil, true
        blank = [nil, nil]
      else
        blank = [Array(blank).first, '']
    end
  end

  selected_value =
    if options.has_key?(:selected)
      options.delete(:selected)
    else
      attributes.get(keys)
    end

  selected_values = {}

  Array(selected_value).flatten.compact.each do |val|
    selected_values[val.to_s] = true
  end

  select_(options_for(options, :name => name, :class => klass, :id => id, :data_error => error)){
    if blank
      content = blank.first || ''
      value = blank.last
      value.nil? ? option_(){ content } : option_(:value => value){ content }
    end

    unless list.empty?
      list.each do |pair|
        returned = block ? Dao.call(block, :call, pair.first, pair.last, selected_value) : pair 

        opts = Map.new
        selected = nil

        case returned
          when Array
            content, value, selected, *ignored = returned
            if value.is_a?(Hash)
              map = Map.for(value)
              value = map.delete(:value)
              selected = map.delete(:selected)
              opts.update(map)
            end

          when Hash
            content = returned[:content]
            value = returned[:value]
            selected = returned[:selected]

          else
            content = returned
            value = returned
            selected = nil
        end

        if selected.nil?
          selected = selected_values.has_key?(value.to_s)
        end

        opts[:value] = (value.nil? ? content : value)
        opts[:selected] = Coerce.boolean(selected) if selected

        option_(opts){ content }
      end
    end
  }
end