dao 2.0.0 → 2.1.0

data/lib/dao/api.rb

@@ -3,7 +3,7 @@ module Dao
     Dao.load 'api/initializers.rb'
     Dao.load 'api/modes.rb'
     Dao.load 'api/context.rb'
-    Dao.load 'api/endpoints.rb'
+    Dao.load 'api/interfaces.rb'
     Dao.load 'api/dsl.rb'
   end
 end

data/lib/dao/api/context.rb

@@ -1,24 +1,24 @@
 module Dao
   class Context
-    Attrs = %w( api endpoint params result method args )
+    Attrs = %w( api interface params result method args )
     Attrs.each{|attr| attr_accessor(attr)}
 
     def initialize(*args, &block)
       options = Dao.options_for!(args)
 
       api = options[:api]
-      endpoint = options[:endpoint]
+      interface = options[:interface]
       params = options[:params]
     
-      params = Params.for(:api => api, :endpoint => endpoint, :params => params)
-      result = Result.new(:api => api, :endpoint => endpoint, :params => params)
+      params = Params.for(:api => api, :interface => interface, :params => params)
+      result = Result.new(:api => api, :interface => interface, :params => params)
       params.result = result
 
-      method = endpoint.method.bind(api)
+      method = interface.method.bind(api)
       args = [params, result].slice(0, method.arity)
 
       self.api = api
-      self.endpoint = endpoint
+      self.interface = interface
       self.params = params
       self.result = result
       self.method = method

data/lib/dao/api/dsl.rb

@@ -16,10 +16,10 @@ module Dao
       end
 
       def no_docs_left_on_stack!
-        raise "no endpoint for #{ docs.inspect }" unless docs.empty?
+        raise "no interface for #{ docs.inspect }" unless docs.empty?
       end
 
-      %w( endpoint doc docs description desc ).each do |method|
+      %w( interface doc docs description desc ).each do |method|
         module_eval <<-__, __FILE__, __LINE__ - 1
 
           def #{ method }(*args, &block)

data/lib/dao/api/interfaces.rb

@@ -0,0 +1,232 @@
+module Dao
+  class Api
+    class << Api
+      def interfaces
+        @interfaces ||= Map.new
+      end
+
+      def interface(path, &block)
+        api = self
+        path = Path.new(path)
+
+        method =
+          module_eval{ 
+            define_method(path + '/interface', &block)
+            instance_method(path + '/interface')
+          }
+
+
+        interface = Interface.new(
+          'api' => api,
+          'path' => path,
+          'method' => method,
+          'doc' => docs.pop
+        )
+
+        interfaces[path] = interface
+      end
+
+      def description(string)
+        doc(:description => Dao.unindent(string))
+      end
+      alias_method('desc', 'description')
+
+      def doc(*args)
+        docs.push(Map[:description, nil]) if docs.empty?
+        doc = docs.last
+        options = Dao.options_for!(args)
+        if options.empty?
+          options[:description] = args.join(' ')
+        end
+        doc.update(options)
+        doc
+      end
+
+      def docs
+        @docs ||= []
+      end
+
+      def index
+        index = Map.new
+        interfaces.each do |path, interface|
+          index[path] = interface.doc || {'description' => path}
+        end
+        index
+      end
+    end
+
+    def call(path = '/index', params = {})
+      api = self
+      path = Path.new(path)
+      interface = interfaces[path]
+      raise(NameError, "NO SUCH INTERFACE: #{ path }") unless interface
+
+      params = Dao.parse(path, params)
+
+      context = Context.new(
+        :api => api,
+        :interface => interface,
+        :params => params
+      )
+
+      callstack(context) do
+        catching(:result){ context.call() }
+      end
+
+      context.result
+    end
+
+    def index
+      self.class.index
+    end
+
+    def interfaces
+      self.class.interfaces
+    end
+
+    def context
+      callstack.last || raise('no context!')
+    end
+
+    def result
+      context.result
+    end
+
+    def params
+      result.params
+    end
+
+    def errors
+      result.errors
+    end
+
+    def apply(hash = {})
+      data.apply(hash)
+    end
+
+    def update(hash = {})
+      data.update(hash)
+    end
+
+    def default(*args)
+      hash = Map.options_for!(args)
+      if hash.empty?
+        value = args.pop
+        key = args
+        hash = {key => value}
+      end
+      data.apply(hash)
+    end
+
+    def status(*args, &block)
+      result.status(*args, &block)
+    end
+
+    def data(*args)
+      if args.empty?
+        result.data
+      else
+        result.data.replace(*args)
+      end
+    end
+
+    def data!(*args)
+      result.data.replace(*args)
+      valid!
+    end
+
+    def update(*args, &block)
+      data.update(*args, &block)
+    end
+
+    def replace(*args, &block)
+      data.replace(*args, &block)
+    end
+
+    def validations
+      result.validations
+    end
+
+    def validates(*args, &block)
+      result.validates(*args, &block)
+    end
+
+    def validate
+      result.validate
+    end
+
+    def valid?
+      result.valid?
+    end
+
+    def validate!
+      result.validate!
+    end
+
+    def valid!
+      result.valid!
+    end
+
+    include Validations::Common
+
+    def return!(*value)
+      throw(:result, *value)
+    end
+
+=begin
+    def set(*args, &block)
+      result.data.set(*args, &block)
+    end
+
+    def get(*args, &block)
+      params.data.get(*args, &block)
+    end
+=end
+
+    def callstack(context = nil, &block)
+      @callstack ||= []
+
+      if block and context
+        begin
+          @callstack.push(context)
+          return block.call()
+        ensure
+          @callstack.pop
+        end
+      else
+        @callstack
+      end
+    end
+
+    def catching(label = :result, &block)
+      @catching ||= []
+
+      if block
+        begin
+          @catching.push(label)
+          catch(label, &block)
+        ensure
+          @catching.pop
+        end
+      else
+        @catching.last
+      end
+    end
+
+    def catching_results(&block)
+      catching(:result, &block)
+    end
+
+    def catching?
+      catching
+    end
+
+    def catching_results?
+      catching == :result
+    end
+
+    def respond_to?(*args)
+      super(*args) || super(Path.absolute_path_for(*args))
+    end
+  end
+end

data/lib/dao/api/modes.rb

@@ -19,7 +19,14 @@ module Dao
 
           def #{ mode }(*args, &block)
             if args.empty?
-              mode(#{ mode.inspect }, &block)
+              if catching_results?
+                if self.mode == #{ mode.inspect }
+                  mode(#{ mode.inspect }, &block)
+                  return!
+                end
+              else
+                mode(#{ mode.inspect }, &block)
+              end
             else
               mode(#{ mode.inspect }) do
                 call(*args, &block)
@@ -68,11 +75,7 @@ module Dao
       if block.nil?
         condition
       else
-        if condition
-          result = block.call
-          throw(:result, result) if catching_the_result?
-          result
-        end
+        send(mode, &block) if condition
       end
     end
   end

data/lib/dao/data.rb

@@ -2,6 +2,13 @@ module Dao
   class Data < ::Map
     add_conversion_method!(:to_dao)
     add_conversion_method!(:as_dao)
+
+    def update(*args, &block)
+      if args.size==1 and args.first.respond_to?(:to_dao)
+        update(args.first.to_dao)
+      end
+      super
+    end
   end
 end
 

data/lib/dao/errors.rb

@@ -1,7 +1,12 @@
 module Dao
   class Errors < ::Map
+    include Tagz.globally
+    class << Errors
+      include Tagz.globally
+    end
+
     Global = '*' unless defined?(Global)
-    Separator = ':' unless defined?(Separator)
+    Separator = '⇒' unless defined?(Separator)
 
     class Message < ::String
       attr_accessor :sticky
@@ -129,7 +134,7 @@ module Dao
     end
 
     def invalid?(*keys)
-      !get(keys).nil?
+      has?(keys) and !get(keys).nil?
     end
 
     alias_method 'on?', 'invalid?'
@@ -146,6 +151,7 @@ module Dao
     alias_method 'length', 'size'
 
     def full_messages
+      global_messages = []
       full_messages = []
 
       depth_first_each do |keys, value|
@@ -153,21 +159,14 @@ module Dao
         key = keys.join('.')
         value = value.to_s
         next if value.strip.empty?
-        full_messages.push([key, value])
-      end
-
-      full_messages.sort! do |a,b|
-        a, b = a.first, b.first
-        if a == Global
-          b == Global ? 0 : -1
-        elsif b == Global
-          a == Global ? 0 : 1
+        if key == Global
+          global_messages.push([key, value])
         else
-          a <=> b
+          full_messages.push([key, value])
         end
       end
 
-      full_messages
+      global_messages + full_messages
     end
 
     def each_message
@@ -208,27 +207,25 @@ module Dao
       options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
       errors = [error, *args].flatten.compact
 
-      at_least_one = false
+      at_least_one_error = false
       css_class = options[:class] || 'dao errors'
 
-      html = []
-
-      html.push("<table class='#{ css_class }'>")
-      html.push("<caption>Sorry, there were some errors.</caption>")
-        errors.each do |e|
-          e.full_messages.each do |key, value|
-            at_least_one = true
-            key = key.to_s
-            html.push("<tr class='field'>")
-              html.push("<td class='field'>#{ key }</td>")
-              html.push("<td class='separator'>#{ Separator }</td>")
-              html.push("<td class='message'>#{ value }</td>")
-            html.push("</tr>")
+      to_html =
+        table_(:class => css_class){
+          caption_{ "We're so sorry, but can you please fix the following errors?" }
+          errors.each do |e|
+            e.full_messages.each do |key, message|
+              at_least_one_error = true
+              tr_{
+                td_(:class => :key){ key }
+                td_(:class => :separator){ Separator }
+                td_(:class => :message){ message }
+              }
+            end
           end
-        end
-      html.push("</table>")
+        }
 
-      at_least_one ? html.join("\n") : ''
+      at_least_one_error ? to_html : '' 
     end
 
     def to_s(*args, &block)

data/lib/dao/form.rb

@@ -24,18 +24,18 @@ module Dao
       super
     end
 
-    def params
-      result.params
-    end
-
-    def ==(other)
-      params.object_id == other.params.object_id
+    def data
+      result.data
     end
 
     def errors
       result.errors
     end
 
+    def ==(other)
+      result == other.result
+    end
+
     def form(*args, &block)
       options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
       keys = args.flatten
@@ -87,9 +87,9 @@ module Dao
 
       value =
         if block.nil? and !options.has_key?(:value) 
-          value_for(params, keys)
+          value_for(data, keys)
         else
-          block ? block.call(params.get(keys)) : options.delete(:value)
+          block ? block.call(data.get(keys)) : options.delete(:value)
         end
 
       input_(options_for(options, :type => type, :name => name, :value => value, :class => klass, :id => id, :data_error => error)){}
@@ -115,9 +115,9 @@ module Dao
 
       value =
         if block.nil? and !options.has_key?(:value) 
-          value_for(params, keys)
+          value_for(data, keys)
         else
-          block ? block.call(params.get(keys)) : options.delete(:value)
+          block ? block.call(data.get(keys)) : options.delete(:value)
         end
 
       button_(options_for(options, :type => type, :name => name, :value => value, :class => klass, :id => id, :data_error => error)){}
@@ -141,12 +141,12 @@ module Dao
 
       value =
         if block.nil? and !options.has_key?(:value) 
-          value_for(params, keys)
+          value_for(data, keys)
         else
-          block ? block.call(params.get(keys)) : options.delete(:value)
+          block ? block.call(data.get(keys)) : options.delete(:value)
         end
 
-      textarea_(options_for(options, :name => name, :class => klass, :id => id, :data_error => error)){ value }
+      textarea_(options_for(options, :name => name, :class => klass, :id => id, :data_error => error)){ value.to_s }
     end
 
     def select(*args, &block)
@@ -154,27 +154,51 @@ module Dao
       keys = args.flatten
 
       name = options.delete(:name) || name_for(keys)
-      from = options.delete(:from) || options.delete(:select) || options.delete(:all) || options.delete(:list)
+      from = options.delete(:from) || options.delete(:options)
 
       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?
+        key = keys.map{|key| "#{ key }"}
+        key.last << "_options"
+        from = data.get(*key) if data.has?(*key)
+      end
+
+      list = Array(from)
+
+
+      case list.first
+        when Hash, Array
+          nil
+        else
+          list.flatten!
+          list.compact!
+          list.map!{|element| [element, element]}
+      end
+
+      selected_value = value_for(data, keys)
+
       select_(options_for(options, :name => name, :class => klass, :id => id, :data_error => error)){
-        pairs = Array(params[from]).flatten
-        pairs.each do |pair|
-          result = block.call(pair)
-          case result
+        list.each do |pair|
+          returned = block.call(pair)
+          case returned
             when Array
-              value, content, selected, *ignored = result
+              value, content, selected, *ignored = returned
             when Hash
-              value = result[:value]
-              content = result[:content] || value
-              selected = result[:selected]
+              value = returned[:value]
+              content = returned[:content] || value
+              selected = returned[:selected]
             else
-              value = result
-              content = result
-              selected = false
+              value = returned
+              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
@@ -204,9 +228,9 @@ module Dao
       end
     end
 
-    def value_for(params, keys)
-      return nil unless params.has?(keys)
-      value = Tagz.escapeHTML(params.get(keys))
+    def value_for(data, keys)
+      return nil unless data.has?(keys)
+      value = Tagz.escapeHTML(data.get(keys))
     end
 
     def name_for(keys)