dao 3.3.0 → 4.2.1

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

@@ -0,0 +1,79 @@
+<%
+
+  conducer_class_name = @conducer_name.camelize
+  controller_class_name = @controller_name.camelize
+
+-%>
+class PostsController < ApplicationController
+  Post = PostConducer
+
+  def index
+    @posts = Post.for_index(params)
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.json  { render :json => @posts }
+    end
+  end
+
+  def show
+    @post = Post.for_show(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.json  { render :json => @post }
+    end
+  end
+
+  def new
+    @post = Post.for_new(params)
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.json  { render :json => @post }
+    end
+  end
+
+  def edit
+    @post = Post.find(params[:id])
+  end
+
+  def create
+    @post = Post.new(params[:post])
+
+    respond_to do |format|
+      if @post.save
+        format.html { redirect_to(@post, :notice => 'Post was successfully created.') }
+        format.json  { render :json => @post, :status => :created, :location => @post }
+      else
+        format.html { render :action => "new" }
+        format.json  { render :json => @post.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  def update
+    @post = Post.find(params[:id])
+
+    respond_to do |format|
+      if @post.update_attributes(params[:post])
+        format.html { redirect_to(@post, :notice => 'Post was successfully updated.') }
+        format.json  { head :ok }
+      else
+        format.html { render :action => "edit" }
+        format.json  { render :json => @post.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  def destroy
+    @post = Post.find(params[:id])
+    @post.destroy
+
+    respond_to do |format|
+      format.html { redirect_to(posts_url) }
+      format.json  { head :ok }
+    end
+  end
+end
+

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

@@ -85,20 +85,27 @@ if(!window.Dao){
 
       };
     };
+    Dao.Api.modes = ["options", "get", "head", "post", "put", "delete", "trace", "connect"];
+    Dao.Api.result = null;
+    Dao.Api.results = [];
+    Dao.Api.defaults = {};
+    Dao.Api.defaults.type = 'get';
+    Dao.Api.defaults.url = '/';
 
-  // meta-program api.read(..), api.post(...), ...
+  // meta-program Dao.Api.get(...), Dao.ajax.post(...)
   //
     for(var i = 0; i < Dao.Api.modes.length; i++){
       (function(){
         var mode = Dao.Api.modes[i];
 
         Dao.Api.prototype[mode] = function(){
+          var args = Array.prototype.slice.call(arguments);
           var api = this;
-          var previous = api.mode;
-          api.mode = mode;
-          var returned = api.call.apply(api, arguments);
-          api.mode = previous;
-          return(returned);
+          var default_type = Dao.Api.defaults.type;
+          Dao.Api.defaults.type = mode.toUpperCase();
+          var result = api.apply(api, args);
+          Dao.Api.defaults.type = default_type;
+          return(result);
         };
       })();
     }

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

@@ -8,20 +8,84 @@ module DaoHelper
     end
   end
 
-  def dao(path, params, mode = nil)
-    unless mode
-      case request.method
-      when "GET"
-        mode = :read
-      when "PUT", "POST", "DELETE"
-        mode = :write
+  def dao(path, *args, &block)
+    options = args.extract_options!.to_options!
+
+    mode = options[:mode]
+
+    if mode.blank?
+      mode =
+        case request.method
+          when "GET"
+            :read
+          when "PUT", "POST", "DELETE"
+            :write
+          else
+            :read
+        end
+    end
+
+    @dao = api.send(mode, path, params)
+    @dao.route = request.fullpath
+    #@dao.mode = mode
+
+    #unless options[:error!] == false
+      @dao.error! unless @dao.status.ok?
+    #end
+
+    block ? block.call(@dao) : @dao
+  end
+
+  def dao_form_for(*args, &block)
+    options = args.extract_options!.to_options!
+
+    model = args.flatten.select{|arg| arg.respond_to?(:new_record?)}.last
+
+    if model
+      first = args.first
+      url = options.delete(:url)
+      method = options.delete(:method)
+      html = dao_form_attrs(options)
+
+      options.clear
+
+      if model.new_record?
+        url ||= url_for(first)
+        method ||= :post
       else
-        # do nothing - the user must specificy the mode explicity
+        url ||= url_for(first)
+        method ||= :put
+      end
+
+      options[:url] = url
+      options[:html] = html.dup.merge(:method => method)
+
+      args.push(options)
+      
+      form_for(*args) do
+        block.call(model.form)
       end
+    else
+      args.push(request.fullpath) if args.empty?
+      args.push(dao_form_attrs(options))
+      form_tag(*args, &block)
     end
-    result = api.send(mode, path, params)
-    result.route = request.fullpath
-    result
   end
+
+  def dao_form_attrs(*args)
+    args.flatten!
+    options = args.extract_options!.to_options!.dup
+    options[:class] ||= []
+    options[:class] = Array(options[:class])
+    options[:class].push('dao')
+    options[:class].push(args.map{|arg| arg.to_s})
+    options[:class].flatten!
+    options[:class].compact!
+    options[:class].uniq!
+    options[:class] = options[:class].join(' ')
+    options[:enctype] ||= "multipart/form-data"
+    options
+  end
+
 end
 ApplicationController.send(:include, DaoHelper)

data/lib/dao/result.rb

@@ -7,38 +7,13 @@ module Dao
       self.route = options[:route] || Route.default
       self.mode = options[:mode] || Mode.default
       self.status = options[:status] || Status.default
-      self.errors = options[:errors] || Errors.new
       self.params = options[:params] || Params.new
+      self.errors = options[:errors] || Errors.new
       self.data = options[:data] || Data.new
-
-      params.result = self
-      params.path = self.path
-      params.status = self.status
-      params.errors = self.errors
-    end
-
-    def error!
-      raise Dao::Error::Result.for(self)
     end
 
-  # look good for inspect
-  #
     def inspect
       ::JSON.pretty_generate(self, :max_nesting => 0)
     end
-
-  # delegate some methods to the params
-  #
-    Validations::Mixin.list.each do |method|
-      module_eval <<-__, __FILE__, __LINE__
-        def #{ method }(*args)
-          params.send(#{ method.inspect }, *args)
-        end
-      __
-    end
-
-    def form
-      params.form
-    end
   end
 end

data/lib/dao/slug.rb

@@ -1,11 +1,40 @@
-module Dao
-  class Slug < ::String
-    def Slug.for(*args)
-      string = args.flatten.compact.join('-')
-      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?}
-      new(words.join('-').downcase)
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+begin
+  require 'unidecode'
+rescue LoadError
+end
+
+class Slug < ::String
+  Slug::Version = '0.0.1'
+
+  def Slug.version
+    '0.0.1'
+  end
+
+  Join = '-'
+
+  def Slug.for(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    join = options[:join]||options['join']||Join
+    string = args.flatten.compact.join(join)
+    string = unidecode(string)
+    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?}
+    new(words.join(join).downcase)
+  end
+
+  unless defined?(Unidecoder)
+    def Slug.unidecode(string)
+      string
+    end
+  else
+    def Slug.unidecode(string)
+      Unidecoder.decode(string)
     end
   end
 end

data/lib/dao/status.rb

@@ -187,6 +187,10 @@ module Dao
     end
     alias_method('set', 'update')
 
+    def ok!
+      update(200)
+    end
+
     Groups.each do |code, group|
       module_eval <<-__, __FILE__, __LINE__ -1
         def Status.#{ group }

data/lib/dao/support.rb

@@ -69,4 +69,159 @@ module Dao
   def parse(*args, &block)
     Params.process(*args, &block)
   end
+
+  def normalize_parameters(params)
+    Params.normalize_parameters(params)
+  end
+
+  def current
+    @current ||=
+      Map.new(
+        :controller => nil
+      )
+  end
+
+  def current_controller(*args)
+    current.controller = args.first unless args.empty?
+    current.controller || mock_controller
+  end
+  alias_method('controller', 'current_controller')
+
+  def current_controller=(controller)
+    current.controller = controller
+  end
+  alias_method('controller=', 'current_controller=')
+
+  %w( request response session ).each do |attr|
+    module_eval <<-__, __FILE__, __LINE__
+      def current_#{ attr }
+        @current_#{ attr } ||= current_controller.instance_eval{ #{ attr } }
+      end
+      def current_#{ attr }=(value)
+        @current_#{ attr } = value
+      end
+      def #{ attr }
+        current_#{ attr }
+      end
+    __
+  end
+
+  %w( current_user effective_user real_user ).each do |attr|
+    module_eval <<-__, __FILE__, __LINE__
+      def #{ attr }
+        @#{ attr } ||= current_controller.instance_eval{ #{ attr } }
+      end
+    __
+  end
+
+  def root
+    if defined?(Rails.root) and Rails.root
+      Rails.root
+    else
+      '.'
+    end
+  end
+
+  def key_for(*keys)
+    key = keys.flatten.join('.').strip
+    key.split(%r/\s*[,.:_-]\s*/).map{|key| key =~ %r/^\d+$/ ? Integer(key) : key}
+  end
+
+  def mock_controller
+    ensure_rails_application do
+      require 'action_dispatch/testing/test_request.rb'
+      require 'action_dispatch/testing/test_response.rb'
+      store = ActiveSupport::Cache::MemoryStore.new
+      controller = 
+        begin
+          ApplicationController.new
+        rescue NameError
+          ActionController::Base.new
+        end
+      controller.perform_caching = true
+      controller.cache_store = store
+      request = ActionDispatch::TestRequest.new
+      response = ActionDispatch::TestResponse.new
+      controller.request = request
+      controller.response = response
+      controller.send(:initialize_template_class, response)
+      controller.send(:assign_shortcuts, request, response)
+      controller.send(:default_url_options).merge!(DefaultUrlOptions) if defined?(DefaultUrlOptions)
+      controller
+    end
+  end
+
+  def ensure_rails_application(&block)
+    if Rails.application.nil?
+      mock = Class.new(Rails::Application)
+      Rails.application = mock.instance
+      begin
+        block.call()
+      ensure
+        Rails.application = nil
+      end
+    else
+      block.call()
+    end
+  end
+
+  def normalize_parameters(params)
+    dao = (params.delete('dao') || {}).merge(params.delete(:dao) || {})
+
+    unless dao.blank?
+      dao.each do |key, paths_and_values|
+        params[key] = nil
+        next if paths_and_values.blank?
+
+        map = Map.new
+
+        paths_and_values.each do |path, value|
+          keys = keys_for(path)
+          map.set(keys => value)
+        end
+
+        params[key] = map
+      end
+    end
+
+    #params[:dao] = {:normalized => true}
+    params
+  end
+
+  def keys_for(keys)
+    keys.strip.split(%r/\s*[,._-]\s*/).map{|key| key =~ %r/^\d+$/ ? Integer(key) : key}
+  end
+
+  def render_json(object, options = {})
+    options = options.to_options!
+    controller = options[:controller] || Dao.current_controller
+
+    controller.instance_eval do
+      json = Dao.json_for(object)
+
+      status = object.status rescue (options[:status] || 200)
+      status = status.code if status.respond_to?(:code)
+
+      respond_to do |wants|
+        wants.json{ render :json => json, :status => status }
+        wants.html{ render :text => json, :status => status, :content_type => 'text/plain' }
+        wants.xml{ render :text => 'no soup for you!', :status => 403 }
+      end
+    end
+  end
+
+  def json_for(object)
+    object = object.as_json if object.respond_to?(:as_json)
+
+    begin
+      if Rails.env.production?
+        ::JSON.generate(object)
+      else
+        ::JSON.pretty_generate(object, :max_nesting => 0)
+      end
+    rescue Object => e
+      Rails.logger.error(e)
+      YAML.load( object.to_yaml ).to_json
+    end
+  end
 end