dao 2.1.0 → 2.2.3

data/lib/dao/rails/lib/generators/dao/templates/api.rb

@@ -24,7 +24,7 @@ Api =
     end
 
     def user_for(arg)
-      User.find(arg)
+      User.respond_to?(:for) ? User.for(arg) : User.find(arg)
     end
 
     alias_method('user', 'effective_user')

data/lib/dao/rails/lib/generators/dao/templates/api_controller.rb

@@ -1,52 +1,39 @@
 class APIController < ApplicationController
   layout false
 
-  skip_before_filter true
   skip_before_filter :verify_authenticity_token
 
   before_filter :setup_path
   before_filter :setup_api
 
-  WhiteList = %w( ping index module )
-
-  ### skip_before_filter :set_current_user if Rails.env.production?
-
-##
-# /api/foo/2/bar/4 -> api.call('/foo/2/bar/4')
-#
-  def call
-    path = params[:path]
-    mode = params['mode'] || (request.get? ? 'read' : 'write')
-
-    result = api.mode(mode).call(path, params)
+  WhiteList = Set.new( %w( ping index ) )
+  BlackList = Set.new( %w( ) )
 
+  def index
+    result = call(path, params)
     respond_with(result)
   end
 
-##
-#
-  def index
-    json = json_for(api.index)
+protected
 
-    respond_to do |wants|
-      wants.json{ render(:json => json) }
-      wants.html{ render(:text => json, :content_type => 'text/plain') }
-    end
+  def call(path, params)
+    mode = params['mode'] || (request.get? ? 'read' : 'write')
+    result = api.mode(mode).call(path, params)
   end
 
-protected
+  def respond_with(object, options = {})
+    json = json_for(object)
 
-  def respond_with(result)
-    json = json_for(result)
+    status = object.status if object.respond_to?(:status)
+    status = status.code if status.respond_to?(:code)
+    status = options[:status] || 200 unless status
 
     respond_to do |wants|
-      wants.json{ render :json => json, :status => result.status.code }
-      wants.html{ render :text => json, :status => result.status.code, :content_type => 'text/plain' }
+      wants.json{ render :json => json, :status => status }
+      wants.html{ render :text => json, :status => status, :content_type => 'text/plain' }
     end
   end
 
-# if you don't have yajl-ruby and yajl/json_gem loaded your json will suck
-#
   def json_for(object)
     if Rails.env.production?
       ::JSON.generate(object)
@@ -56,7 +43,7 @@ protected
   end
 
   def setup_path
-    @path = params[:path]
+    @path = params[:path] || params[:action] || 'index'
   end
 
   def path
@@ -97,14 +84,21 @@ protected
   end
 
   def self.white_listed?(path)
-    @white_listed ||= ( WhiteList.inject(Hash.new){|hash, path| hash.update(path.to_s => true)} )
-    @white_listed[path.to_s]
+    WhiteList.include?(path.to_s)
   end
 
   def white_listed?(path)
     self.class.white_listed?(path)
   end
 
+  def self.black_listed?(path)
+    BlackList.include?(path.to_s)
+  end
+
+  def black_listed?(path)
+    self.class.black_listed?(path)
+  end
+
   def http_basic_auth
     @http_basic_auth ||= (
       request.env['HTTP_AUTHORIZATION']   ||

data/lib/dao/rails/lib/generators/dao/templates/dao.js

@@ -37,8 +37,14 @@ if(!window.Dao){
 
       if(arguments.length > 1){
         options.path = arguments[0];
-        options.params = arguments[1];
-        options.success = arguments[2];
+
+        if(typeof(arguments[1])=='function'){
+          options.success = arguments[1];
+          options.params = arguments[2];
+        } else {
+          options.params = arguments[1];
+          options.success = arguments[2];
+        }
       }
 
       if(!options.path){
@@ -49,35 +55,35 @@ if(!window.Dao){
         options.params = {};
       }
 
-      if(!options.success){
-        options.success = function(result){
-          result = new Dao.Result(result);
-          api.result = result;
-          api.results.push(result);
-        };
-      }
-
       var url = api.route + options.path;
-
       var data = options.params;
 
-      var success = function(result){
-        var result = new Dao.Result(result);
-        if(options.success){
+      if(options.success){
+
+        var returned = api;
+        var success = function(result){
+          var result = new Dao.Result(result);
           options.success(result);
-        } else {
-          api.result = result;
-          api.results.push(result);
-        }
-      };
+        };
 
-      var ajax = {};
-      ajax.url = url;
-      ajax.data = data;
-      ajax.success = success;
+        var ajax = {'url' : url, 'data' : data, 'success' : success, 'async' : true};
+
+        Dao[api.mode](ajax);
+        return(returned);
 
-      Dao[api.mode](ajax);
-      return(api);
+      } else {
+
+        var returned = null;
+        var success = function(result){
+          returned = new Dao.Result(result);
+        };
+
+        var ajax = {'url' : url, 'data' : data, 'success' : success, 'async' : false};
+
+        Dao[api.mode](ajax);
+        return(returned);
+
+      };
     };
 
   // meta-program api.read(..), api.post(...), ...
@@ -120,6 +126,9 @@ if(!window.Dao){
       ajax.url = options.url;
       ajax.dataType = 'json';
       ajax.cache = false;
+      if(options.async==false || options.sync==true){
+        ajax.async = false;
+      };
       if(ajax.type == 'POST' || ajax.type == 'PUT'){
         ajax.data = jq.toJSON(options.data || {});
       } else {

data/lib/dao/rails/lib/generators/dao/templates/dao_helper.rb

@@ -1,9 +1,10 @@
 module DaoHelper
   def render_dao(result, *args, &block)
     if result.status =~ 200 or result.status == 420
+      @result = result unless defined?(@result)
       render(*args, &block)
     else
-      render(:text => result.status, :status => result.status.code)
+      result.error!
     end
   end
 end

data/lib/dao/result.rb

@@ -7,6 +7,7 @@ module Dao
     attr_accessor :mode
     attr_accessor :params
     attr_accessor :validations
+    attr_accessor :presenter
     attr_accessor :form
     attr_accessor :forcing_validity
 
@@ -18,11 +19,19 @@ module Dao
       options = Dao.options_for!(args)
       args.push('/dao') if args.empty?
 
-      path = Path.for(*args)
+      path_args = args.select{|arg| arg.is_a?(String) or args.is_a?(Symbol)}
+      data_args = args.select{|arg| arg.is_a?(Hash)}
+      data_args += [options[:data]] if options.has_key?(:data)
+
+      path = Path.for(*path_args)
       status = Status.ok
       errors = Errors.new
       data = Data.new
 
+      data_args.each do |data_arg|
+        data.update(data_arg)
+      end
+
       api = options[:api]
       interface = options[:interface]
       params = options[:params] || Params.new
@@ -33,6 +42,7 @@ module Dao
 
       form = Form.for(self)
       validations = Validations.for(self) 
+      presenter = Presenter.for(self) 
 
       self[:path] = path
       self[:status] = status
@@ -45,6 +55,7 @@ module Dao
       @params = params
       @form = form
       @validations = validations
+      @presenter = presenter
       @forcing_validity = false
     end
 
@@ -90,11 +101,13 @@ module Dao
       @forcing_validity = true
     end
 
-    def valid?
+    def valid?(*args)
       if @forcing_validity
         true
       else
+        options = Dao.options_for!(args)
         validate unless validations.ran?
+        validate if options[:validate]
         errors.empty? and status.ok?
       end
     end
@@ -122,5 +135,17 @@ module Dao
     def validates(*args, &block)
       validations.add(*args, &block)
     end
+
+    def error!
+      raise Dao::Error::Result.for(self)
+    end
+
+    def tag(*args, &block)
+      presenter.tag(*args, &block)
+    end
+
+    def inspect
+      ::JSON.pretty_generate(self, :max_nesting => 0)
+    end
   end
 end

data/lib/dao/status.rb

@@ -113,6 +113,10 @@ module Dao
     Groups.each do |code, group|
       module_eval <<-__, __FILE__, __LINE__ -1
 
+        def Status.#{ group }
+          @status_group_#{ group } ||= Status.for(#{ code })
+        end
+
         def #{ group }?()
           #{ code } == @group
         end
@@ -183,8 +187,12 @@ module Dao
               message = Code2Message[code]
               new(code, message)
             when Symbol, String
-              sym = Status.underscore(arg).to_sym
-              code = Symbol2Code[sym]
+              if arg.to_s =~ %r/^\d+$/
+                code = arg.to_i
+              else
+                sym = Status.underscore(arg).to_sym
+                code = Symbol2Code[sym]
+              end
               if code
                 message = Code2Message[code]
               else

data/lib/dao/support.rb

@@ -65,6 +65,6 @@ module Dao
   end
 
   def name_for(path, *keys)
-    "#{ path }(#{ Array(keys).flatten.compact.join(',') })"
+    Form.name_for(path, *keys)
   end
 end

data/lib/dao/validations.rb

@@ -28,6 +28,8 @@ module Dao
     end
 
 
+  # class methods
+  #
     class << Validations
       def for(*args, &block)
         new(*args, &block)
@@ -43,6 +45,8 @@ module Dao
       end
     end
 
+  # instance methods
+  #
     attr_accessor :result
     attr_accessor :ran
 
@@ -51,7 +55,6 @@ module Dao
       @ran = false
       super
     end
-
     alias_method('ran?', 'ran')
 
     def params
@@ -75,11 +78,10 @@ module Dao
       depth_first_each{ size += 1 }
       size
     end
-
     alias_method('count', 'size')
     alias_method('length', 'size')
 
-    Cleared = '___CLEARED___'.freeze unless defined?(Cleared)
+    Cleared = 'Cleared'.freeze unless defined?(Cleared)
 
     def run
       previous_errors = []
@@ -88,8 +90,7 @@ module Dao
       errors.each_message do |keys, message|
         previous_errors.push([keys, message])
       end
-
-      errors.clear
+      errors.clear!
 
       depth_first_each do |keys, chain|
         chain.each do |callback|
@@ -158,12 +159,10 @@ module Dao
       options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
       block = args.pop if args.last.respond_to?(:call)
       block ||= NotNil
-      callback = Validations::Callback.new(options, &block)
+      callback = Callback.new(options, &block)
       set(args => Callback::Chain.new) unless has?(args)
       get(args).add(callback)
       callback
-      #args.push(callback)
-      #set(*args)
     end
   end
 
@@ -429,6 +428,142 @@ module Dao
 
       validates(*args, &block)
     end
+
+    def validates_any_of(*args)
+      options = Dao.options_for!(args)
+      list = args
+
+      list.each do |args|
+        candidates = list.dup
+        candidates.delete(args)
+
+        message = options[:message] || "(or #{ candidates.map{|candidate| Array(candidate).join('.')}.join(', ') } ) is blank or missing"
+        allow_nil = options[:allow_nil]
+        allow_blank = options[:allow_blank]
+
+        result = self.result
+
+        block =
+          lambda do |value|
+            map = Dao.map(:valid => true)
+            values = list.map{|key| result.get(key)}
+            valid = false
+            values.each do |val|
+              if val
+                valid = true
+                break
+              end
+
+              if val.nil?
+                if allow_nil
+                  valid = true
+                  break
+                end
+              end
+
+              val = val.to_s.strip
+
+              if val.empty?
+                if allow_blank
+                  valid = true
+                  break
+                end
+              end
+            end
+
+            unless valid
+              if value.nil?
+                unless allow_nil
+                  map[:message] = message
+                  map[:valid] = false
+                  throw(:valid, map)
+                end
+              end
+
+              value = value.to_s.strip
+
+              if value.empty?
+                unless allow_blank
+                  map[:message] = message
+                  map[:valid] = false
+                  throw(:valid, map)
+                end
+              end
+            end
+
+            map
+          end
+        validates(*args, &block)
+      end
+    end
+
+    def validates_all_of(*args)
+      options = Dao.options_for!(args)
+      list = args
+
+      list.each do |args|
+        candidates = list.dup
+        candidates.delete(args)
+
+        message = options[:message] || "(and #{ candidates.map{|candidate| Array(candidate).join('.')}.join(', ') } ) is blank or missing"
+        allow_nil = options[:allow_nil]
+        allow_blank = options[:allow_blank]
+
+        result = self.result
+
+        block =
+          lambda do |value|
+            map = Dao.map(:valid => true)
+
+            values = list.map{|key| result.get(key)}
+            valid = true
+            values.each do |val|
+              if val
+                break
+              end
+
+              if val.nil?
+                unless allow_nil
+                  valid = false
+                  break
+                end
+              end
+
+              val = val.to_s.strip
+
+              if val.empty?
+                unless allow_blank
+                  valid = false
+                  break
+                end
+              end
+            end
+
+            unless valid
+              if value.nil?
+                unless allow_nil
+                  map[:message] = message
+                  map[:valid] = false
+                  throw(:valid, map)
+                end
+              end
+
+              value = value.to_s.strip
+
+              if value.empty?
+                unless allow_blank
+                  map[:message] = message
+                  map[:valid] = false
+                  throw(:valid, map)
+                end
+              end
+            end
+
+            map
+          end
+        validates(*args, &block)
+      end
+    end
   end
 
   def Validations.add(method_name, &block)