dao 2.0.0 → 2.1.0

data/sample/rails_app/pubic/javascripts/dao.js

@@ -0,0 +1,148 @@
+if(!window.Dao){
+  (function(){
+    window.Dao = {};
+
+  // pull jQuery off the CDN iff needed 
+  //
+    !window.jQuery && document.write(unescape('%3Cscript src="js/libs/jquery-1.4.2.js"%3E%3C/script%3E'));
+    var jq = jQuery;
+
+  // ctor
+  //
+    Dao.Api = function(){
+      this.route = '' + Dao.Api.route;
+      this.result = null;
+      this.results = [];
+      this.mode = 'get';
+      this.method = Dao[this.mode];
+    };
+    Dao.Api.route = '/api';
+    Dao.Api.modes = ["options", "get", "head", "post", "put", "delete", "trace", "connect"];
+
+  // single call interface
+  //
+    Dao.Api.prototype.call = function(){
+      var api = this;
+      var options = {};
+
+      if(arguments.length == 1){
+        var arg = arguments[0];
+
+        if(typeof(arg)=='string'){
+          options.path = arg;
+        } else {
+          options = arg;
+        }
+      }
+
+      if(arguments.length > 1){
+        options.path = arguments[0];
+        options.params = arguments[1];
+        options.success = arguments[2];
+      }
+
+      if(!options.path){
+        options.path = '/ping';
+      }
+
+      if(!options.params){
+        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){
+          options.success(result);
+        } else {
+          api.result = result;
+          api.results.push(result);
+        }
+      };
+
+      var ajax = {};
+      ajax.url = url;
+      ajax.data = data;
+      ajax.success = success;
+
+      Dao[api.mode](ajax);
+      return(api);
+    };
+
+  // meta-program api.read(..), api.post(...), ...
+  //
+    for(var i = 0; i < Dao.Api.modes.length; i++){
+      (function(){
+        var mode = Dao.Api.modes[i];
+
+        Dao.Api.prototype[mode] = function(){
+          var api = this;
+          var previous = api.mode;
+          api.mode = mode;
+          var returned = api.call.apply(api, arguments);
+          api.mode = previous;
+          return(returned);
+        };
+      })();
+    }
+    Dao.Api.prototype['read'] = Dao.Api.prototype['get'];
+    Dao.Api.prototype['write'] = Dao.Api.prototype['post'];
+
+  // a thin wrapper on results for now.  TODO - make it smarter
+  //
+    Dao.Result = function(options){
+      this.path = options.path;
+      this.status = options.status;
+      this.errors = options.errors;
+      this.data = options.data;
+
+      //parts = ('' + this.status).split(/\s+/);
+      //this.status.code = parseInt(parts.shift()); 
+      //this.status.message = parts.join(' ');
+    };
+
+  // ajax utils
+  //
+    Dao.ajax = function(options){
+      var ajax = {};
+      ajax.type = options.type;
+      ajax.url = options.url;
+      ajax.dataType = 'json';
+      if(ajax.type == 'POST' || ajax.type == 'PUT'){
+        ajax.data = jq.toJSON(options.data || {});
+      } else {
+        ajax.data = (options.data || {});
+      };
+      ajax.contentType = (options.contentType || 'application/json; charset=utf-8');
+      ajax.success = (options.success || function(){});
+      jq.ajax(ajax);
+    };
+
+  // meta-program Api.get(...), Api.post(...)
+  //
+    for(var i = 0; i < Dao.Api.modes.length; i++){
+      (function(){
+        var mode = Dao.Api.modes[i];
+
+        Dao[mode] = function(options){
+          options.type = mode.toUpperCase();
+          Dao.ajax(options);
+        };
+      })();
+    }
+
+    Dao.api = new Dao.Api();
+    window.api = window.api || Dao.api;
+  }());
+}

data/test/dao_test.rb

@@ -19,13 +19,13 @@ Testing Dao do
     }
   end
 
-  testing 'that apis can have callable endpoints added to them which accept params and return results' do
+  testing 'that apis can have callable interfaces added to them which accept params and return results' do
     captured = []
 
     api_class =
       assert{
         Dao.api do
-          endpoint(:foo) do |params, result|
+          interface(:foo) do |params, result|
             captured.push(params, result)
           end
         end
@@ -35,20 +35,20 @@ Testing Dao do
     assert{ result.is_a?(Hash) }
   end
 
-  testing 'that endpoints are automatically called according to arity' do
+  testing 'that interfaces are automatically called according to arity' do
     api = assert{ Class.new(Dao.api) }
-    assert{ api.class_eval{ endpoint(:zero){|| result.update :args => [] } } }
-    assert{ api.class_eval{ endpoint(:one){|a| result.update :args => [a]} } }
-    assert{ api.class_eval{ endpoint(:two){|a,b| result.update :args => [a,b]} } }
+    assert{ api.class_eval{ interface(:zero){|| result.update :args => [] } } }
+    assert{ api.class_eval{ interface(:one){|a| result.update :args => [a]} } }
+    assert{ api.class_eval{ interface(:two){|a,b| result.update :args => [a,b]} } }
 
     assert{ api.new.call(:zero).args.size == 0 }
     assert{ api.new.call(:one).args.size == 1 }
     assert{ api.new.call(:two).args.size == 2 }
   end
 
-  testing 'that endpoints have an auto-vivifying params/result' do
+  testing 'that interfaces have an auto-vivifying params/result' do
     api = assert{ Class.new(Dao.api) }
-    assert{ api.class_eval{ endpoint(:foo){ params; result; } } }
+    assert{ api.class_eval{ interface(:foo){ params; result; } } }
     result = assert{ api.new.call(:foo) }
     assert{ result.path.to_s =~ /foo/ }
   end
@@ -136,7 +136,7 @@ Testing Dao do
     assert{
       api_class =
         Dao.api do
-          endpoint('/foobar'){
+          interface('/foobar'){
             data.update(params)
           }
         end
@@ -185,7 +185,7 @@ Testing Dao do
   testing 'that simple validations work' do
     result = Dao::Result.new
     assert{ result.validates(:password){|password| password=='haxor'} }
-    result.params.set(:password, 'haxor')
+    result.data.set(:password, 'haxor')
     assert{ result.valid? }
   end
 
@@ -193,7 +193,7 @@ Testing Dao do
     assert{
       api_class =
         Dao.api do
-          endpoint('/foobar'){
+          interface('/foobar'){
             result.validates(:a)
             params.validate(:b)
             validates(:c)
@@ -209,19 +209,18 @@ Testing Dao do
 #
   testing 'that validations can be cleared and do not clobber manually added errors' do
     result = Dao::Result.new
-    params = result.params
-    params = result.params
+    data = result.data
     errors = result.errors
 
     assert{ result.validates(:email){|email| email.to_s.split(/@/).size == 2} }
-    assert{ result.validates(:password){|password| password == 'haxor'} }
+    assert{ result.validates(:password){|password| password == 'pa$$w0rd'} }
 
-    params.set(:email => 'ara@dojo4.com', :password => 'fubar')
-    assert{ not result.valid? }
-
-    params.set(:password => 'haxor')
+    data.set(:email => 'ara@dojo4.com', :password => 'pa$$w0rd')
     assert{ result.valid? }
 
+    data.set(:password => 'haxor')
+    assert{ !result.valid? }
+
     errors.add(:name, 'ara')
     assert{ not result.valid? }
   end
@@ -234,7 +233,7 @@ Testing Dao do
         Dao.api {
           description 'foobar'
           doc 'signature' => {'read' => '...', 'write' => '...'} 
-          endpoint('/barfoo'){}
+          interface('/barfoo'){}
         }
       }
     api_class_index = assert{ api_class.index.is_a?(Hash) }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dao
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: 
   segments: 
   - 2
+  - 1
   - 0
-  - 0
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors: 
 - Ara T. Howard
@@ -15,35 +15,39 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-28 00:00:00 -07:00
+date: 2011-02-22 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: map
+  name: tagz
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 87
         segments: 
+        - 8
+        - 2
         - 0
-        version: "0"
+        version: 8.2.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: tagz
+  name: map
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 21
         segments: 
-        - 0
-        version: "0"
+        - 2
+        - 6
+        - 1
+        version: 2.6.1
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -52,12 +56,14 @@ dependencies:
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 17
         segments: 
         - 0
-        version: "0"
+        - 7
+        - 9
+        version: 0.7.9
   type: :runtime
   version_requirements: *id003
 description: "description: dao kicks the ass"
@@ -70,12 +76,12 @@ extra_rdoc_files: []
 
 files: 
 - dao.gemspec
-- db/dao.yml
 - lib/dao/active_record.rb
 - lib/dao/api/context.rb
 - lib/dao/api/dsl.rb
 - lib/dao/api/endpoints.rb
 - lib/dao/api/initializers.rb
+- lib/dao/api/interfaces.rb
 - lib/dao/api/modes.rb
 - lib/dao/api.rb
 - lib/dao/blankslate.rb
@@ -86,6 +92,8 @@ files:
 - lib/dao/errors.rb
 - lib/dao/exceptions.rb
 - lib/dao/form.rb
+- lib/dao/instance_exec.rb
+- lib/dao/interface.rb
 - lib/dao/mode.rb
 - lib/dao/mongo_mapper.rb
 - lib/dao/params.rb
@@ -96,6 +104,9 @@ files:
 - lib/dao/rails/lib/generators/dao/dao_generator.rb
 - lib/dao/rails/lib/generators/dao/templates/api.rb
 - lib/dao/rails/lib/generators/dao/templates/api_controller.rb
+- lib/dao/rails/lib/generators/dao/templates/dao.css
+- lib/dao/rails/lib/generators/dao/templates/dao.js
+- lib/dao/rails/lib/generators/dao/templates/dao_helper.rb
 - lib/dao/rails/lib/generators/dao/USAGE
 - lib/dao/rails.rb
 - lib/dao/result.rb
@@ -136,6 +147,7 @@ files:
 - sample/rails_app/log/production.log
 - sample/rails_app/log/server.log
 - sample/rails_app/log/test.log
+- sample/rails_app/pubic/javascripts/dao.js
 - sample/rails_app/public/404.html
 - sample/rails_app/public/422.html
 - sample/rails_app/public/500.html
@@ -157,7 +169,6 @@ files:
 - test/dao_test.rb
 - test/helper.rb
 - test/testing.rb
-- TODO
 has_rdoc: true
 homepage: http://github.com/ahoward/dao
 licenses: []

data/TODO

@@ -1,37 +0,0 @@
-todo:
-
-  route -> path??
-
-  - nested AR conversions
-      to_dao(:a, :b => [:foo, :bar])
-
-  - AR as_dao contains the model type/class.name
-
-
-done:
-    - engine-ify the rails stuff?  or what
-      - generator api
-      - controller
-      - helper
-      - json/pretty fix baked in? (yajl might simply this...)
-  - description/doc logic
-  - api.index
-  - to_alpo -> to_dao
-  - tests!
-  - #call auto parses data iff appropriate
-      @result = api.read.call('/posts/new(', params)  ### check keys for '/posts/new'
-  - re-visit how parameters are parsed, perhaps we just use rack?
-  - next 'data' => {}
-  - check the db layer
-  - make sure one can call route based method (/foo/:bar) methods with params...
-  - Path==Route ??
-  - add result.rb, params.rb
-  - name -> path
-  - tagz for html methods?
-  - data aquires the name/path of the method?
-  - endpoints are objects that respond to call.  namespaces respond to call.
-    api responds to call
-  - nested namespaces
-  - routing for path_info + mode 
-      route(path_info, :mode => mode, :params => params)
-  - call() on namespaces AND endpoints... why?

data/db/dao.yml

@@ -1,8 +0,0 @@
---- 
-"42": {}
-
-users: 
-  "42": 
-    a: :b
-    time: 2011-01-26 13:27:36.996654 -07:00
-    id: 42