dao 2.1.0 → 2.2.3

data/lib/dao/form.rb

@@ -60,19 +60,19 @@ module Dao
       options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
       keys = args.flatten
 
-      name = options.delete(:name) || keys.last
       id = options.delete(:id) || id_for(keys)
       klass = class_for(keys, options.delete(:class))
       error = error_for(keys, options.delete(:error))
+      target = options.delete(:for) || id_for(keys)
 
       content =
-        if block.nil? and !options.has_key?(:content) 
-          name.to_s.humanize
+        if block.nil? and !options.has_key?(:content)
+          humanize(keys.last)
         else
           block ? block.call() : options.delete(:content)
         end
 
-      label_(options_for(options, :name => name, :class => klass, :id => id, :data_error => error)){ content }
+      label_(options_for(options, :for => target, :class => klass, :id => id, :data_error => error)){ content }
     end
 
     def input(*args, &block)
@@ -97,10 +97,14 @@ module Dao
 
     def submit(*args, &block)
       options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
-      options[:type] = :submit
-      options[:value] = block ? block.call : :Submit
-      args.push(options)
-      input(*args)
+
+      content = block ? block.call : (args.first || 'Submit')
+
+      options[:name] ||= :submit
+      options[:type] ||= :submit
+      options[:value] ||= content
+
+      input_(options_for(options)){}
     end
 
     def button(*args)
@@ -156,6 +160,13 @@ module Dao
       name = options.delete(:name) || name_for(keys)
       from = options.delete(:from) || options.delete(:options)
 
+      selected =
+        if options.has_key?(:selected)
+          options.delete(:selected)
+        else
+          value_for(data, keys)
+        end
+
       id = options.delete(:id) || id_for(keys)
       klass = class_for(keys, options.delete(:class))
       error = error_for(keys, options.delete(:error))
@@ -170,7 +181,6 @@ module Dao
 
       list = Array(from)
 
-
       case list.first
         when Hash, Array
           nil
@@ -180,11 +190,21 @@ module Dao
           list.map!{|element| [element, element]}
       end
 
-      selected_value = value_for(data, keys)
+      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
+        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
               value, content, selected, *ignored = returned
@@ -197,9 +217,11 @@ module Dao
               content = returned
               selected = nil
           end
+
           if selected.nil?
             selected = value.to_s==selected_value.to_s
           end
+
           opts = {:value => value}
           opts[:selected] = !!selected if selected
           option_(opts){ content }
@@ -233,8 +255,24 @@ module Dao
       value = Tagz.escapeHTML(data.get(keys))
     end
 
+    def Form.name_for(path, *keys)
+      path = Path.new(path) unless path.is_a?(Path)
+      "#{ path }(#{ Array(keys).flatten.compact.join(',') })"
+    end
+
+    def Form.name_re_for(path)
+      path = Path.new(path) unless path.is_a?(Path)
+      Regexp.new(/^#{ Regexp.escape(path) }/)
+    end
+
+    def Form.encoded?(path, params)
+      name_re = Form.name_re_for(path)
+      params.keys.any?{|key| name_re =~ key.to_s}
+    end
+
+
     def name_for(keys)
-      "#{ result.path }(#{ Array(keys).flatten.compact.join(',') })"
+      Form.name_for(result.path, keys)
     end
 
     def options_for(*hashes)
@@ -256,5 +294,11 @@ module Dao
     def attr_for(string)
       slug_for(string).gsub(/_/, '-')
     end
+
+    def humanize(string)
+      string = string.to_s
+      string = string.humanize if string.respond_to?(:humanize)
+      string
+    end
   end
 end

data/lib/dao/params.rb

@@ -3,9 +3,11 @@ module Dao
     include Dao::InstanceExec
 
     class << Params
-      def parse(prefix, params = {})
+      def parse(prefix, params = {}, options = {})
         prefix = prefix.to_s
-        params = Map.new(params)
+        params = Map.new(params || {})
+        base = Map.new(params || {})
+        options = Map.options(options || {})
         parsed = Params.new
         parsed.update(params[prefix]) if params.has_key?(prefix)
 
@@ -17,11 +19,44 @@ module Dao
           matched, keys = re.match(key).to_a
           next unless matched
           next unless keys
-          keys = keys.strip.split(%r/\s*,\s*/).map{|key| key =~ %r/^\d+$/ ? Integer(key) : key}
+          keys = keys_for(keys)
           parsed.set(keys => value)
+          base.delete(key)
         end
 
-        parsed
+        whitelist = Set.new( [options.getopt([:include, :select, :only])].flatten.compact.map{|k| k.to_s} )
+        blacklist = Set.new( [options.getopt([:exclude, :reject, :except])].flatten.compact.map{|k| k.to_s} )
+
+        unless blacklist.empty?
+          base.keys.dup.each do |key|
+            base.delete(key) if blacklist.include?(key.to_s)
+          end
+        end
+
+        unless whitelist.empty?
+          base.keys.dup.each do |key|
+            base.delete(key) unless whitelist.include?(key.to_s)
+          end
+        end
+
+        if options.getopt(:fold, default=true)
+          parsed_and_folded = base.merge(parsed)
+        else
+          parsed
+        end
+      end
+
+      def keys_for(keys)
+        keys.strip.split(%r/\s*,\s*/).map{|key| key =~ %r/^\d+$/ ? Integer(key) : key}
+      end
+
+      def process(path, params, options = {})
+        return params if params.is_a?(Params)
+
+        parsed = Params.parse(path, params, options)
+        return parsed unless parsed.empty?
+
+        return Params.new(params)
       end
     end
 
@@ -82,52 +117,7 @@ module Dao
     end
   end
 
-  def Dao.parse(path, params)
-    return params if params.is_a?(Params)
-
-    smells_like_unparsed_rails_params = (
-      params.has_key?(:action) and
-      params.has_key?(:controller) and
-      params.class.name =~ /HashWithIndifferentAccess/
-    )
-    return(Params.parse(path.to_s, params)) if smells_like_unparsed_rails_params
-
-    smells_like_unparsed_params = false
-    unparsed_re = %r/^#{ Regexp.escape(path.to_s) }/
-    params.each do |key, val|
-      if key =~ unparsed_re
-        smells_like_unparsed_params = true
-        break
-      end
-    end
-    return(Params.parse(path.to_s, params)) if smells_like_unparsed_params
-
-    return Params.new(params) 
-  end
-
-=begin
-  def Dao.parse(path, params)
-    returned = Params.new(params)
-
-    smells_like_rails = (params.has_key?(:action) and params.has_key?(:controller) and params.class.name =~ /HashWithIndifferentAccess/)
-    if smells_like_rails
-      returned.delete(:action)
-      returned.delete(:controller)
-      returned.update(Params.parse(path, params))
-      return returned
-    end
-
-    re = %r/^#{ Regexp.escape(path) }/
-    smells_like_unparsed = false
-    params.each do |key, val|
-      break(smells_like_unparsed = true) if key =~ re
-    end
-    if smells_like_unparsed
-      returned.update(Params.parse(path, params))
-      return returned
-    end
-
-    return returned
+  def Dao.parse(*args, &block)
+    Params.process(*args, &block)
   end
-=end
 end

data/lib/dao/presenter.rb

@@ -0,0 +1,129 @@
+module Dao
+  class Presenter
+    include Tagz.globally
+
+    class << Presenter 
+      def for(*args, &block)
+        new(*args, &block)
+      end
+    end
+
+    attr_accessor :result
+    attr_accessor :formats
+
+    def initialize(*args, &block)
+      @result = args.shift if args.first.is_a?(Result)
+      @formats = Map.new
+    end
+
+    %w( set get has has? [] ).each do |method|
+      module_eval <<-__, __FILE__, __LINE__
+        def #{ method }(*args, &block)
+          data.#{ method }(*args, &block)
+        end
+      __
+    end
+
+    def extend(*args, &block)
+      return super if block.nil?
+      singleton_class =
+        class << self
+          self
+        end
+      singleton_class.module_eval(&block)
+    end
+
+    def tag(*args, &block)
+      options = Dao.options_for!(args)
+      args.push(:div) if args.empty?
+      tagname = args.shift
+      keys = args
+
+      tag_method = "#{ tagname }_"
+
+      id = options.delete(:id) || id_for(keys)
+      klass = class_for(keys, options.delete(:class))
+      error = error_for(keys, options.delete(:error))
+
+      tag_options =
+        options_for(options, :id => id, :class => klass, :data_error => error)
+
+      value = value_for(keys)
+      tag_value = instance_exec(value, &format_for(keys))
+
+      send(tag_method, tag_options){ tag_value }
+    end
+
+    include InstanceExec
+
+    DefaultFormat = lambda{|value| value}
+
+    def format_for(keys)
+      formats.get(keys) || DefaultFormat
+    end
+
+    def format(list_of_keys, &block)
+      Array(list_of_keys).each do |keys|
+        formats.set(keys, block)
+      end
+    end
+
+    def data
+      result.data
+    end
+
+    def errors
+      result.errors
+    end
+
+    def ==(other)
+      result == other.result
+    end
+
+    def id_for(keys)
+      id = [result.path, keys.join('-')].compact.join('_')
+      slug_for(id)
+    end
+
+    def class_for(keys, klass = nil)
+      klass = 
+        if result.errors.on?(keys)
+          [klass, 'dao', 'errors'].compact.join(' ')
+        else
+          [klass, 'dao'].compact.join(' ')
+        end
+      klass
+    end
+
+    def error_for(keys, klass = nil)
+      if result.errors.on?(keys)
+        result.errors.get(keys)
+      end
+    end
+
+    def value_for(keys)
+      return nil unless data.has?(keys)
+      value = Tagz.escapeHTML(data.get(keys))
+    end
+
+    def options_for(*hashes)
+      map = Map.new
+      hashes.flatten.each do |h|
+        h.each{|k,v| map[attr_for(k)] = v unless v.nil?}
+      end
+      map
+    end
+
+    def slug_for(string)
+      string = string.to_s
+      words = string.to_s.scan(%r/\w+/)
+      words.map!{|word| word.gsub(%r/[^0-9a-zA-Z_:-]/, '')}
+      words.delete_if{|word| word.nil? or word.strip.empty?}
+      words.join('-').downcase.sub(/_+$/, '')
+    end
+
+    def attr_for(string)
+      slug_for(string).gsub(/_/, '-')
+    end
+  end
+end

data/lib/dao/rails.rb

@@ -7,12 +7,60 @@ if defined?(Rails)
       ### ref: https://gist.github.com/af7e572c2dc973add221
 
       paths.path = ROOT_DIR
+
       ### config.autoload_paths << APP_DIR
       ### $LOAD_PATH.push(File.join(Rails.root.to_s, 'app'))
-
       #config.after_initialize do
         #unloadable(Dao)
       #end
+       
+
+    # yes yes, this should probably be somewhere else...
+    #
+      config.after_initialize do
+
+        ActionController::Base.module_eval do
+
+        # you will likely want to override this!
+        #
+          def current_api
+            @api ||= ( 
+              api = Api.new
+              %w( real_user effective_user current_user ).each do |attr|
+                getter = "#{ attr }"
+                setter = "#{ attr }="
+                if respond_to?(getter) and api.respond_to?(setter)
+                  api.send(setter, send(getter))
+                end
+              end
+              api
+            )
+          end
+          helper_method(:current_api)
+          alias_method(:api, :current_api)
+          helper_method(:api)
+
+        # setup sane rescuing from dao errors with crap statuses
+        #
+          rescue_from(Dao::Error::Result) do |error|
+            result = error.result
+            basename = "#{ result.status.code }.html"
+            error_page = File.join(Rails.root, 'public', basename)
+
+            if test(?e, error_page)
+              file = File.expand_path(error_page)
+              status = result.status.code
+              render(:file => file, :status => status, :layout => false)
+            else
+              text = result.status.to_s
+              status = result.status.code
+              render(:text => text, :status => status, :layout => false)
+            end
+          end
+        end
+
+      end
+
     end
   end
 end

data/lib/dao/rails/lib/generators/dao/dao_generator.rb

@@ -12,8 +12,7 @@ class DaoGenerator < Rails::Generators::NamedBase
 
     copy_file("dao.css", "public/stylesheets/dao.css")
 
-    route("match 'api/*path' => 'api#call', :as => 'api'")
-    route("match 'api' => 'api#index', :as => 'api_index'")
+    route("match 'api(/*path)' => 'api#index', :as => 'api'")
 
     gem("yajl-ruby")