dao 2.0.0 → 2.1.0

data/lib/dao/instance_exec.rb

@@ -0,0 +1,37 @@
+module Dao
+  module InstanceExec
+    Code = lambda do
+      unless Object.new.respond_to?(:instance_exec)
+        module InstanceExecHelper; end
+        include InstanceExecHelper
+
+        def instance_exec(*args, &block)
+          begin
+            old_critical, Thread.critical = Thread.critical, true
+            n = 0
+            n += 1 while respond_to?(mname="__instance_exec_#{ n }__")
+            InstanceExecHelper.module_eval{ define_method(mname, &block) }
+          ensure
+            Thread.critical = old_critical
+          end
+          begin
+            ret = send(mname, *args)
+          ensure
+            InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+          end
+          ret
+        end
+      end
+    end
+
+    def InstanceExec.included(other)
+      other.module_eval(&Code)
+      super
+    end
+
+    def InstanceExec.extend_object(other)
+      other.instance_eval(&Code)
+      super
+    end
+  end
+end

data/lib/dao/interface.rb

@@ -0,0 +1,16 @@
+module Dao
+  class Interface
+    Attrs = %w( api path method doc )
+    Attrs.each{|attr| attr_accessor(attr)}
+
+    def initialize(options = {})
+      update(options)
+    end
+
+    def update(options = {})
+      options.each do |key, val|
+        send("#{ key }=", val)
+      end
+    end
+  end
+end

data/lib/dao/params.rb

@@ -1,5 +1,7 @@
 module Dao
   class Params < ::Map
+    include Dao::InstanceExec
+
     class << Params
       def parse(prefix, params = {})
         prefix = prefix.to_s
@@ -24,7 +26,7 @@ module Dao
     end
 
     attr_accessor :api
-    attr_accessor :endpoint
+    attr_accessor :interface
     attr_accessor :params
     attr_accessor :result
 
@@ -32,12 +34,12 @@ module Dao
       options = Dao.options_for!(args)
 
       api = options[:api]
-      endpoint = options[:endpoint]
+      interface = options[:interface]
       updates = options[:params]
 
       params = new()
       params.api = api
-      params.endpoint = endpoint
+      params.interface = interface
 
       params.update(updates) if updates
 
@@ -78,32 +80,54 @@ module Dao
     def validate!
       result.validate! if result
     end
+  end
 
-    unless Object.new.respond_to?(:instance_exec)
-      module InstanceExecHelper; end
-      include InstanceExecHelper
-
-      def instance_exec(*args, &block)
-        begin
-          old_critical, Thread.critical = Thread.critical, true
-          n = 0
-          n += 1 while respond_to?(mname="__instance_exec_#{ n }__")
-          InstanceExecHelper.module_eval{ define_method(mname, &block) }
-        ensure
-          Thread.critical = old_critical
-        end
-        begin
-          ret = send(mname, *args)
-        ensure
-          InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
-        end
-        ret
+  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
 
-  def Dao.parse(*args, &block)
-    Params.parse(*args, &block)
+    return returned
   end
+=end
 end

data/lib/dao/path.rb

@@ -78,7 +78,7 @@ module Dao
     attr_accessor :keys
     attr_accessor :pattern
     attr_accessor :params
-    attr_accessor :endpoint
+    attr_accessor :interface
 
     def initialize(*args, &block)
       super(args.join('/'), &block)

data/lib/dao/rails.rb

@@ -3,13 +3,16 @@ if defined?(Rails)
     class Engine < Rails::Engine
       GEM_DIR = File.expand_path(__FILE__ + '/../../../')
       ROOT_DIR = File.join(GEM_DIR, 'lib/dao/rails')
-      #APP_DIR = File.join(ROOT_DIR, 'app')
 
-      ### https://gist.github.com/af7e572c2dc973add221
+      ### 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
     end
   end
 end

data/lib/dao/rails/app/api.rb

@@ -2,7 +2,7 @@ Api =
   Dao.api do
 
     description 'ping!'
-    endpoint('/ping'){
+    interface('/ping'){
       data.update :time => Time.now
     }
 

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

@@ -6,6 +6,12 @@ class DaoGenerator < Rails::Generators::NamedBase
 
     copy_file("api_controller.rb", "app/controllers/api_controller.rb")
 
+    copy_file("dao_helper.rb", "app/helpers/dao_helper.rb")
+
+    copy_file("dao.js", "public/javascripts/dao.js")
+
+    copy_file("dao.css", "public/stylesheets/dao.css")
+
     route("match 'api/*path' => 'api#call', :as => 'api'")
     route("match 'api' => 'api#index', :as => 'api_index'")
 
@@ -21,6 +27,12 @@ class DaoGenerator < Rails::Generators::NamedBase
 
         config.autoload_paths += %w( app )
 
+        ### config.action_view.javascript_expansions[:defaults] ||= []
+        ### config.action_view.javascript_expansions[:defaults] += %( dao )
+
+        ### config.action_view.stylesheet_expansions[:defaults] ||= []
+        ### config.action_view.stylesheet_expansions[:defaults] += %( dao )
+
       __
     )
   end

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

@@ -2,7 +2,7 @@ Api =
   Dao.api do
 
     description 'ping!'
-    endpoint('/ping'){
+    interface('/ping'){
       data.update :time => Time.now
     }
 
@@ -29,6 +29,8 @@ Api =
 
     alias_method('user', 'effective_user')
     alias_method('user=', 'effective_user=')
+    alias_method('current_user', 'effective_user')
+    alias_method('current_user=', 'effective_user=')
 
     def api
       self
@@ -53,3 +55,7 @@ Api =
 
 
 unloadable(Api)
+
+def api(*args, &block)
+  Api.new(*args, &block)
+end

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

@@ -4,8 +4,11 @@ class APIController < ApplicationController
   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?
 
 ##
@@ -52,7 +55,20 @@ protected
     end
   end
 
+  def setup_path
+    @path = params[:path]
+  end
+
+  def path
+    @path
+  end
+
   def setup_api
+    if white_listed?(path)
+      @api = Api.new
+      return
+    end
+
     email, password = http_basic_auth_info
 
     if !email.blank? and !password.blank?
@@ -80,6 +96,15 @@ protected
     @api
   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]
+  end
+
+  def white_listed?(path)
+    self.class.white_listed?(path)
+  end
+
   def http_basic_auth
     @http_basic_auth ||= (
       request.env['HTTP_AUTHORIZATION']   ||

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

@@ -0,0 +1,27 @@
+/* dao errors */
+table.dao.errors {
+  font-weight: normal;
+  width: 100%;
+  border-bottom: 1px solid #ccc;
+}
+table.dao.errors caption {
+  font-weight: bold;
+  color: #333;
+  font-style: italic;
+  text-align: left;
+  margin-bottom: 0.5em;
+}
+table.dao.errors td.key {
+  padding-left: 1em;
+  color: #666;
+}
+table.dao.errors td.separator {
+  color: #666;
+  padding-left: 0.5em;
+  padding-right: 0.5em;
+}
+table.dao.errors td.message {
+  font-style: italic;
+  width: 100%;
+}
+

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

@@ -0,0 +1,149 @@
+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';
+      ajax.cache = false;
+      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;
+  }());
+}