dao 4.4.4 → 4.6.4

data/lib/dao/conducer/active_model.rb

@@ -35,7 +35,14 @@ module Dao
 
       def default_model_name
         return model_name_for('Conducer') if self == Dao::Conducer
-        model_name_for(name.to_s.sub(/Conducer$/, '').sub(/(:|_)+$/, ''))
+
+        suffixes = /(Conducer|Resource|Importer|Presenter|Conductor|Cell)\Z/o
+
+        name = self.name.to_s
+        name.sub!(suffixes, '') unless name.sub(suffixes, '').blank?
+        name.sub!(/(:|_)+$/, '')
+
+        model_name_for(name)
       end
 
       def collection_name

data/lib/dao/conducer/collection.rb

@@ -13,6 +13,10 @@ module Dao
       def collection_for(models, *args, &block)
         collection_class.load(models, *args, &block)
       end
+
+      def collection
+        collection_class
+      end
     end
 
     class Collection < ::Array

data/lib/dao/conducer/controller_support.rb

@@ -18,10 +18,14 @@ module Dao
       def set_controller(controller)
         @controller = controller
       ensure
-        default_url_options[:protocol] = @controller.request.protocol
-        default_url_options[:host] = @controller.request.host
-        default_url_options[:port] = @controller.request.port
-        @action = Action.new(@controller.send(:action_name).to_s, self)
+        if defined?(default_url_options)
+          [:protocol, :host, :port].each{|attr| default_url_options[attr] = @controller.request.send(attr)}
+        end
+        @action = Action.new((@controller.send(:action_name) || :index).to_s, self)
+      end
+
+      def request
+        @controller.send(:request) if @controller
       end
 
     ##

data/lib/dao/conducer/nav_support.rb

@@ -2,9 +2,10 @@
 module Dao
   class Conducer
     def nav_for(*args, &block)
-      Nav.new(*args, &block).for(controller)
+      Nav.build(*args, &block)
     end
     alias_method(:nav, :nav_for)
     alias_method(:navigation, :nav_for)
+    alias_method(:navigation_for, :nav_for)
   end
 end

data/lib/dao/conducer/view_support.rb

@@ -6,11 +6,15 @@ module Dao
 
       class << Conducer
         include Tagz.globally
-      end
 
-      url_helpers = Rails.application.try(:routes).try(:url_helpers)
-      include(url_helpers) if url_helpers
-      include(ActionView::Helpers) if defined?(ActionView::Helpers)
+        def install_routes!
+          url_helpers = Rails.application.try(:routes).try(:url_helpers)
+          include(url_helpers) if url_helpers
+          include(ActionView::Helpers) if defined?(ActionView::Helpers)
+          extend(url_helpers) if url_helpers
+          extend(ActionView::Helpers) if defined?(ActionView::Helpers)
+        end
+      end
     end
   end
 end

data/lib/dao/errors.rb

@@ -113,31 +113,21 @@ module Dao
     alias_method('add_to_base', 'add')
     alias_method('add_to_base!', 'add!')
 
-    def relay(other, options = {})
-      case
-        when other.respond_to?(:each)
-          other.each do |key, messages|
-            Array(messages).each do |message|
-              add(key, message, options = {})
-            end
-          end
-        when other.respond_to?(:each_pair)
-          other.each_pair do |key, messages|
-            Array(messages).each do |message|
-              add(key, message, options = {})
-            end
-          end
+    def relay(*args)
+      options = args.size > 1 ? Map.options_for!(args) : Map.new
 
-        when other.respond_to?(:each_slice)
-          Array(other).flatten.each_slice(2) do |key, messages|
-            Array(messages).each do |message|
-              add(key, message, options = {})
-            end
-          end
+      prefix = Array(options.delete(:prefix))
 
-        else
-          raise(ArgumentError, other.class.name)
+      args.flatten.compact.each do |source|
+        errors = source.respond_to?(:errors) ? source.errors : source
+
+        errors.each do |*argv|
+          msgs = Array(argv.pop)
+          key = prefix + Array(argv.pop)
+          msgs.each{|msg| add(Array(options[:key] || key), msg, options)}
+        end
       end
+
       self
     end
 
@@ -181,7 +171,9 @@ module Dao
         index = keys.pop
         key = keys
         value = value.to_s
+
         next if value.strip.empty?
+
         if key == Global
           global_messages.push([key, value])
         else
@@ -200,6 +192,18 @@ module Dao
       end
     end
 
+    def flatten
+      hash = Hash.new
+
+      depth_first_each do |keys, value|
+        index = keys.pop
+        hash[keys] ||= []
+        hash[keys].push("#{ value }")
+      end
+
+      hash
+    end
+
     def each_full_message
       full_messages.each{|msg| yield msg}
     end
@@ -212,6 +216,14 @@ module Dao
         select{|message| not message.strip.empty?}
     end
 
+    def global
+      reject{|k, v| k != Global}
+    end
+
+    def local
+      reject{|k, v| k == Global}
+    end
+
   # html generation methods
   #
     def to_html(*args)
@@ -222,50 +234,104 @@ module Dao
       if block
         define_method(:to_html, &block)
       else
-        default_errors_to_html(*args)
+        errors_to_html(*args)
       end
     end
 
-    def Errors.default_errors_to_html(*args)
+    def Errors.errors_to_html(*args)
+      ::Errors2Html.to_html(*args)
+    end
+
+    def to_s(format = :html, *args, &block)
+      case format.to_s
+        when /html/
+          to_html(*args, &block)
+
+        when /text/
+          to_text(*args, &block)
+      end
+    end
+
+    class KeyPrefixer
+      attr_accessor :object
+      attr_accessor :prefix
+      attr_accessor :global
+
+      def initialize(object)
+        @object = object
+
+        @prefix =
+          if @object && @object.respond_to?(:model_name)
+            @object.model_name.underscore
+          else
+            nil
+          end
+
+        @global = Array(Global)
+      end
+
+      def prefix(key)
+        is_global_key = key == @global || Array(key) == @global
+
+        if @prefix
+          if is_global_key
+            @prefix
+          else
+            ["#{ @prefix }.#{ key[0] }", *key[1..-1]]
+          end
+        else
+          if is_global_key
+            'global'
+          else
+            key
+          end
+        end
+      end
+    end
+
+    def key_prefixer
+      @key_prefixer ||= KeyPrefixer.new(object)
+    end
+
+    def prefix_key(key)
+      key_prefixer.prefix(key)
+    end
+
+    def Errors.to_hash(*args)
       error = args.shift
       options = Map.options_for!(args)
       errors = [error, *args].flatten.compact
 
-      at_least_one_error = false
-
-      emap = Map.new
+      map = Map.new
 
       errors.each do |e|
         e.full_messages.each do |key, message|
-          at_least_one_error = true
-          emap[key] ||= message
+          k = e.key_prefixer.prefix(key)
+
+          map.set(k, []) unless map.has?(k)
+          map.get(k).push("#{ message }")
         end
       end
 
-      return "" unless at_least_one_error
-
-      div_(:class => "dao errors summary"){
-        __
-
-        h3_(:class => "caption"){ "We're so sorry, but can you please fix the following errors?" }
-        __
+      map.to_hash
+    end
 
-        dl_(:class => "list"){
-          emap.each do |key, message|
-            title = Array(key).join(" ").titleize
+    def to_hash
+      Errors.to_hash(self)
+    end
 
-            type = Array(key) == Array(Global) ? "global" : "field"
+    def Errors.errors_to_text(*args)
+      hash = to_hash(*args)
 
-            dt_(:class => "title #{ type }"){ title }
-            dd_(:class => "message #{ type }"){ message }
-          end
-        }
-        __
-      }
+      if hash.empty?
+        nil
+      else
+        hash.to_yaml
+      end
     end
 
-    def to_s(*args, &block)
-      to_html(*args, &block)
+    def to_text
+      Errors.errors_to_text(self)
     end
   end
 end

data/lib/dao/form.rb

@@ -11,9 +11,20 @@ module Dao
 
   # builder stuff for compatibity with rails' form_for()
   #
-    class Builder
+    class Builder < Form
       def Builder.new(object_name, object, view, options, block)
-        form = Form.new(object)
+        if object.respond_to?(:form)
+
+          html = options[:html] || {}
+          html[:class] ||= 'dao'
+          unless html[:class] =~ /(\s|\A)dao(\Z|\s)/o
+            html[:class] << ' dao dao-form'
+          end
+
+          object.form
+        else
+          raise ArgumentError, object.class.name
+        end
       end
     end
 
@@ -69,14 +80,17 @@ module Dao
 
     fattr(:name) do
       name =
-        catch(:name) do
-          if @object.respond_to?(:name)
-            throw :name, @object.name
-          end
-          if @object.instance_variable_defined?('@name')
-            throw :name, @object.instance_variable_get('@name')
-          end
-          'form'
+        case
+          when @object.respond_to?(:form_name)
+            @object.form_name
+          when @object.respond_to?(:name)
+            @object.name
+          when @object.instance_variable_defined?('@form_name')
+            @object.instance_variable_get('@form_name')
+          when @object.instance_variable_defined?('@name')
+            @object.instance_variable_get('@name')
+          else
+            :form
         end
 
       case name
@@ -107,28 +121,24 @@ module Dao
       end
     end
 
-    fattr(:status) do
-      status =
-        catch(:status) do
-          if @object.respond_to?(:status)
-            throw :status, @object.status
-          end
-          if @object.instance_variable_defined?('@status')
-            throw :status, @object.instance_variable_get('@status')
-          end
-          Status.new
-        end
+  # support for rails' forms...
+  #
+    fattr(:multipart){ true }
 
-      case status
-        when Status
-          status
-        else
-          raise(ArgumentError.new("#{ status.inspect } (#{ status.class })"))
-      end
+    %w( [] []= get set has has? ).each do |method|
+      class_eval <<-__
+        def #{ method }(*args, &block)
+          attributes.#{ method }(*args, &block)
+        end
+      __
     end
 
   # html generation methods 
   #
+    def element(which, *args, &block)
+      send(which, *args, &block)
+    end
+
     def form(*args, &block)
       options = args.extract_options!.to_options! 
       keys = args.flatten
@@ -153,11 +163,11 @@ module Dao
       options = args.extract_options!.to_options! 
       keys = args.flatten
 
-      content =
-        if block.nil?
+      block ||=
+        proc do
+          options.delete(:content) ||
+          options.delete(:value) ||
           keys.map{|key| key.to_s.titleize}.join(' ')
-        else
-          block ? block.call() : (options.delete(:content) || options.delete(:value))
         end
 
       id = options.delete(:id) || id_for(keys + [:label])
@@ -165,7 +175,7 @@ module Dao
       error = error_for(keys, options.delete(:error))
       target = options.delete(:for) || id_for(keys)
 
-      label_(options_for(options, :for => target, :class => klass, :id => id, :data_error => error)){ content }
+      label_(options_for(options, :for => target, :class => klass, :id => id, :data_error => error), &block)
     end
 
     def input(*args, &block)
@@ -210,14 +220,11 @@ module Dao
       klass = class_for(keys, options.delete(:class))
       error = error_for(keys, options.delete(:error))
 
-      value =
-        if block.nil? and !options.has_key?(:value) 
-          value_for(attributes, keys)
-        else
-          block ? block.call(attributes.get(keys)) : options.delete(:value)
-        end
+      value = options.has_key?(:value) ? options.delete(:value) : value_for(attributes, keys)
+
+      content = (block ? block.call : (options.delete(:content) || 'Submit'))
 
-      button_(options_for(options, :type => type, :name => name, :value => value, :class => klass, :id => id, :data_error => error)){}
+      button_(options_for(options, :type => type, :name => name, :value => value, :class => klass, :id => id, :data_error => error)){ content }
     end
 
     def radio_button(*args, &block)
@@ -257,7 +264,7 @@ module Dao
       values = options.delete(:values) || options.delete(:checked)
 
       unless options.has_key?(:checked)
-        checked = !!attributes.get(keys)
+        checked = Coerce.boolean(attributes.get(keys))
         options[:checked] = checked if checked
       end
 
@@ -336,29 +343,22 @@ module Dao
       keys = args.flatten
 
       name = options.delete(:name) || name_for(keys)
-      from = options.delete(:from) || options.delete(:options)
-      blank = options.delete(:blank)
+      values = options.delete(:values) || options.delete(:options) || options.delete(:from)
 
-      selected =
-        if options.has_key?(:selected)
-          options.delete(:selected)
-        else
-          value_for(attributes, keys)
-        end
+      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))
 
-      block ||= lambda{|pair| pair = Array(pair).flatten.compact; [pair.first, pair.last, selected=nil]}
-
-      if from.nil?
+      if values.nil?
         key = keys.map{|key| "#{ key }"}
         key.last << "_options"
-        from = attributes.get(*key) if attributes.has?(*key)
+        values = attributes.get(*key) if attributes.has?(*key)
       end
 
-      list = Array(from)
+      list = Array(values).map{|value| value.dup rescue value} # ensure list is dup'd
 
       case list.first
         when Hash, Array
@@ -369,52 +369,68 @@ module Dao
           list.map!{|element| [element, element]}
       end
 
-      case blank
-        when nil, false
-          nil
-        when true
-          list.push(nil)
-        else
-          list.unshift(blank)
+      if has_blank
+        case blank
+          when false
+            blank = nil
+          when nil, true
+            blank = [nil, nil]
+          else
+            blank = [Array(blank).first, '']
+        end
       end
 
       selected_value =
-        case selected
-          when Array
-            selected.first
-          when Hash
-            key = [:id, 'id', :value, 'value'].detect{|k| selected.has_key?(k)}
-            key ? selected[key] : selected
-          else
-            selected
+        if options.has_key?(:selected)
+          options.delete(:selected)
+        else
+          value_for(attributes, keys)
         end
 
       select_(options_for(options, :name => name, :class => klass, :id => id, :data_error => error)){
-        list.each do |pair|
-          returned = block.call(pair)
-
-          case returned
-            when Array
-              content, value, selected, *ignored = returned
-            when Hash
-              content = returned[:content]
-              value = returned[:value]
-              selected = returned[:selected]
-            else
-              content = returned
-              value = returned
-              selected = nil
-          end
-
-          value ||= content
+        if blank
+          content = blank.first || ''
+          value = blank.last
+          value.nil? ? option_(){ content } : option_(:value => value){ content }
+        end
 
-          if selected.nil?
-            selected = value.to_s==selected_value.to_s
+        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 = (value.to_s == selected_value.to_s)
+            end
+
+            opts[:value] = (value.nil? ? content : value)
+            opts[:selected] = Coerce.boolean(selected) if selected
+
+            option_(opts){ content }
           end
-
-          opts = {:value => value}
-          opts[:selected] = !!selected if selected
-          option_(opts){ content }
         end
       }
     end
@@ -521,6 +537,7 @@ module Dao
 
     def options_for(*hashes)
       map = Map.new
+
       hashes.flatten.each do |h|
         case((data = h.delete(:data) || h.delete('data')))
           when Hash
@@ -533,6 +550,11 @@ module Dao
           map[attr_for(k)] = v unless v.nil?
         end
       end
+
+      %w( readonly disabled autofocus checked multiple ).each do |attr|
+        map.delete(attr) unless Coerce.boolean(map[attr])
+      end
+
       map
     end