dao 3.3.0 → 4.2.1

data/lib/dao/instance_exec.rb

@@ -1,6 +1,6 @@
 module Dao
   module InstanceExec
-    Code = lambda do
+    Code = proc do
       unless Object.new.respond_to?(:instance_exec)
         module InstanceExecHelper; end
         include InstanceExecHelper

data/lib/dao/name.rb

@@ -0,0 +1,7 @@
+module Dao
+  class Name < ::String
+    def Name.for(name)
+      name.is_a?(Name) ? name : Name.new(name)
+    end
+  end
+end

data/lib/dao/params.rb

@@ -2,87 +2,37 @@ module Dao
   class Params < ::Map
   # mixins
   #
-    include Validations::Mixin
+    include Validations
 
   # class methods
   #
     class << Params
-      def parse(prefix, params = {}, options = {})
-        prefix = prefix.to_s
-        params = Map.new(params || {})
-        base = Map.new(params || {})
-        options = Map.options(options || {})
-        parsed = Params.new
-        parsed.update(params[prefix]) if params.has_key?(prefix)
-
-        re = %r/^ #{ Regexp.escape(prefix) } (?: [(] ([^)]+) [)] )? $/x
-
-        params.each do |key, value|
-          next unless(key.is_a?(String) or key.is_a?(Symbol))
-          key = key.to_s
-          matched, keys = re.match(key).to_a
-          next unless matched
-          next unless keys
-          keys = keys_for(keys)
-          parsed.set(keys => value)
-          base.delete(key)
-        end
-
-        whitelist = Set.new( [options.getopt([:include, :select, :only])].flatten.compact.map{|k| k.to_s} )
-        blacklist = Set.new( [options.getopt([:exclude, :reject, :except])].flatten.compact.map{|k| k.to_s} )
-
-        unless blacklist.empty?
-          base.keys.dup.each do |key|
-            base.delete(key) if blacklist.include?(key.to_s)
-          end
-        end
-
-        unless whitelist.empty?
-          base.keys.dup.each do |key|
-            base.delete(key) unless whitelist.include?(key.to_s)
-          end
-        end
-
-        if options.getopt(:fold, default=true)
-          parsed_and_folded = base.merge(parsed)
-        else
-          parsed
-        end
-      end
-
-      def keys_for(keys)
-        keys.strip.split(%r/\s*,\s*/).map{|key| key =~ %r/^\d+$/ ? Integer(key) : key}
-      end
-
-      def process(path, params, options = {})
-        return params if params.is_a?(Params)
-
-        parsed = Params.parse(path, params, options)
-        return parsed unless parsed.empty?
-
-        return Params.new(params)
-      end
     end
 
   # instance methods
   #
-    attr_accessor :result
-    attr_accessor :route
     attr_accessor :path
-    attr_accessor :status
-    attr_accessor :errors
-    attr_accessor :validations
+    attr_accessor :route
     attr_accessor :form
 
     def initialize(*args, &block)
-      @path = Path.default
-      @status = Status.default
-      @errors = Errors.new
-      @validations = Validations.for(self)
-      @form = Form.for(self)
+      options = Dao.options_for!(args)
+
+      @path = args.shift || options[:path] || Path.default
+      @route = options[:route] || Route.default
+      @form = options[:form] || Form.for(self)
+
+      update(options[:params]) if options[:params]
+
       super
     end
 
+    def attributes
+      self
+    end
+
+    fattr(:name){ path }
+
   # look good for inspect
   #
     def inspect

data/lib/dao/rack.rb

@@ -0,0 +1,3 @@
+if defined?(Rack)
+  Dao.load %w[ rack/middleware.rb ]
+end

data/lib/dao/rack/middleware.rb

@@ -0,0 +1,5 @@
+module Dao
+  module Middleware 
+    Dao.load %w[ rack/middleware/params_parser.rb ]
+  end
+end

data/lib/dao/rack/middleware/params_parser.rb

@@ -0,0 +1,24 @@
+module Dao
+  module Middleware 
+    class ParamsParser
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @env = env
+        #if params = parse_formatted_parameters(env)
+          #env["action_dispatch.request.request_parameters"] = params
+        #end
+
+        query_parameters = @env["action_controller.request.query_parameters"]
+        request_parameters = @env["action_controller.request.request_parameters"]
+
+        Rails.logger.info("query_parameters : #{ query_parameters.inspect }")
+        Rails.logger.info("request_parameters : #{ request_parameters.inspect }")
+
+        @app.call(@env)
+      end
+    end
+  end
+end

data/lib/dao/rails.rb

@@ -17,26 +17,43 @@ if defined?(Rails)
 
       paths.path = ROOT_DIR
 
+      config.autoload_paths += %w( app/models app )
+
       ### config.autoload_paths << APP_DIR
       ### $LOAD_PATH.push(File.join(Rails.root.to_s, 'app'))
 
+    # drop the dao parameter parser in there...
+    #
+      #initializer "dao.middleware" do |app|
+        #app.middleware.use Dao::Middleware::ParamsParser
+      #end
+
     # yes yes, this should probably be somewhere else...
     #
       config.after_initialize do
 
         ActionController::Base.module_eval do
 
+          before_filter do |controller|
+          # set the dao controller
+          #
+            Dao.current_controller = controller
+
+          # pre-parse any obvious dao params
+          #
+            controller.instance_eval do
+              Dao.normalize_parameters(params)
+            end
+          end
+
         # you will likely want to override this!
         #
           def current_api
             @api ||= ( 
               api = Api.new
               %w( real_user effective_user current_user ).each do |attr|
-                getter = "#{ attr }"
-                setter = "#{ attr }="
-                if respond_to?(getter) and api.respond_to?(setter)
-                  api.send(setter, send(getter))
-                end
+                getter, setter = "#{ attr }", "#{ attr }="
+                api.send(setter, send(getter)) if(respond_to?(getter) and api.respond_to?(setter))
               end
               api
             )

data/lib/dao/rails/lib/generators/dao/USAGE

@@ -1,9 +1,5 @@
 Description:
-  rails generate dao api
-  rails generate dao api controller
-  rails generate dao paths
+  rails generate dao system
 
 Example:
-  rails generate dao api
-  rails generate dao api controller
-  rails generate dao paths
+  rails generate dao system

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

@@ -1,15 +1,60 @@
 class DaoGenerator < Rails::Generators::NamedBase
-  source_root File.expand_path('../templates', __FILE__)
+  source_root(File.expand_path('../templates', __FILE__))
 
-  def copy_api_file
-    copy_file("api.rb", "app/api.rb")
+  def copy_files
+    ARGV.shift if ARGV.first == name
 
-    copy_file("api_controller.rb", "app/controllers/api_controller.rb")
+    case name
+      when /conducer_controller/
+        generate_conducer_controller!
+
+      when /conducer/
+        generate_conducer!
+      
+      when /system/
+        generate_system!
+
+      when /api/
+        generate_system!
+
+      when /conducers/
+        generate_system!
+
+      when /assets/
+        generate_system!
 
+      else
+        raise "dunno how to generate #{ name.inspect }"
+    end
+  end
+
+protected
+  def generate_conducer_controller!
+    @conducer_name = ARGV.shift.sub(/_?conducer$/i, '') + '_conducer'
+    @controller_name = @conducer_name.sub(/_conducer/, '_controller')
+
+    template "conducer_controller.rb", "app/controllers/#{ @conducer_name.underscore }.rb"
+    #template "conducer.rb", "app/conducers/#{ @conducer_name.underscore }.rb"
+  end
+
+  def generate_conducer!
+    @conducer_name = ARGV.shift.sub(/_?conducer$/i, '') + '_conducer'
+    template "conducer.rb", "app/conducers/#{ @conducer_name.underscore }.rb"
+  end
+
+  def generate_system!
+    dao_dir = File.join(Rails.root, 'app/dao')
+
+    FileUtils.mkdir_p(dao_dir)
+    FileUtils.mkdir_p(File.join(dao_dir, 'apis'))
+    FileUtils.mkdir_p(File.join(dao_dir, 'conducers'))
+
+    copy_file("api.rb", "app/dao/api.rb")
+
+    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#index', :as => 'api'")
@@ -20,11 +65,11 @@ class DaoGenerator < Rails::Generators::NamedBase
       <<-__
 
         config.after_initialize do
-          require 'app/api.rb'
+          require 'app/dao/api.rb'
           require 'yajl/json_gem'
         end
 
-        config.autoload_paths += %w( app )
+        config.autoload_paths += %w( app/models app/dao app/dao/apis app/dao/conducers )
 
         ### config.action_view.javascript_expansions[:defaults] ||= []
         ### config.action_view.javascript_expansions[:defaults] += %( dao )

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

@@ -12,12 +12,12 @@ Api =
 
   ##
   #
-    doc '/ping - hello world without a user'
+    desc '/ping - hello world without a user'
     call('/ping'){
       data.update :time => Time.now
     }
 
-    doc '/pong - hello world with a user'
+    desc '/pong - hello world with a user'
     call('/pong'){
       require_current_user!
       data.update :time => Time.now
@@ -48,6 +48,8 @@ Api =
     alias_method('user=', 'effective_user=')
     alias_method('current_user', 'effective_user')
     alias_method('current_user=', 'effective_user=')
+    alias_method('effective_user?', 'effective_user')
+    alias_method('real_user?', 'real_user')
 
     def api
       self
@@ -77,7 +79,7 @@ Api =
     end
 
     def require_real_user!
-      unless effective_user?
+      unless real_user?
         status :unauthorized
         return!
       end
@@ -89,9 +91,23 @@ Api =
     alias_method('require_user!', 'require_current_user!')
   end
 
+## look for any other apis to load
+#
+  %w( api apis ).each do |dir|
+    glob = File.expand_path(File.join(Rails.root, "app/#{ dir }/**/*.rb"))
+    files = Dir.glob(glob).sort
+    files.each{|file| ::Kernel.load(file)}
+  end
 
-unloadable(Api)
+## mo betta in development
+#
+  unloadable(Api)
 
-def api(*args, &block)
-  Api.new(*args, &block)
-end
+## top level method shortcut
+#
+  module Kernel
+  protected
+    def api(*args, &block)
+      Api.new(*args, &block)
+    end
+  end

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

@@ -3,8 +3,9 @@ class APIController < ApplicationController
 
   skip_before_filter :verify_authenticity_token
 
-  before_filter :setup_path
   before_filter :setup_api
+  before_filter :setup_mode
+  before_filter :setup_path
 
   WhiteList = Set.new( %w( ping index ) )
   BlackList = Set.new( %w( ) )
@@ -17,8 +18,7 @@ class APIController < ApplicationController
 protected
 
   def call(path, params)
-    mode = params['mode'] || (request.get? ? 'read' : 'write')
-    result = api.mode(mode).call(path, params)
+    @result = api.mode(@mode).call(path, params)
   end
 
   def respond_with(object, options = {})
@@ -30,25 +30,42 @@ protected
     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
 
   def json_for(object)
-    if Rails.env.production?
-      ::JSON.generate(object)
-    else
-      ::JSON.pretty_generate(object, :max_nesting => 0)
+    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
 
   def setup_path
     @path = params[:path] || params[:action] || 'index'
+    unless api.route?(@path) or @path=='index'
+      render :nothing => true, :status => 404
+    end
+  end
+
+  def setup_mode
+    @mode = params['mode'] || (request.get? ? 'read' : 'write')
   end
 
   def path
     @path
   end
 
+  def mode
+    @mode
+  end
+
 ##
 # you'll likely want to customize this for you app as it makes a few
 # assumptions about how to find and authenticate users

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

@@ -0,0 +1,64 @@
+<%
+
+  class_name = @conducer_name.camelize
+  model_name = class_name.sub(/Conducer/, '') 
+
+-%>
+class <%= class_name %> < Dao::Conducer
+## class_methods
+#
+  class << <%= class_name %>
+    def all(params = {})
+      records = <%= model_name %>.paginate(params)
+
+      records.map! do |record|
+        new(record.attributes)
+      end
+    end
+
+    def find(id)
+      raise NotImplementedError, <<-__
+        this needs to return an instance based on the id
+      __
+    end
+  end
+
+## instance_methods
+#
+  def initialize
+    run_callbacks :initialize do
+    end
+  end
+
+  def save
+    run_callbacks :save do
+      return(false) unless valid?
+
+      raise NotImplementedError, <<-__
+        this needs to
+          - persist data to the db and get a new id
+          - set the id on the object : @attributes.set(:id => id)
+          - return true or false
+      __
+
+      true
+    end
+  end
+
+  def destroy
+    run_callbacks :destroy do
+      id = self.id
+      if id
+
+        raise NotImplementedError, <<-__
+          this needs to
+            - un-persist data from the db
+            - set the id on the object to nil : @attributes.rm(:id)
+            - return this id of the destroyed object 
+        __
+
+      end
+      id
+    end
+  end
+end