dao 2.2.3 → 3.1.0

data/lib/dao/api.rb

@@ -2,6 +2,7 @@ module Dao
   class Api
     Dao.load 'api/initializers.rb'
     Dao.load 'api/modes.rb'
+    Dao.load 'api/routes.rb'
     Dao.load 'api/context.rb'
     Dao.load 'api/interfaces.rb'
     Dao.load 'api/dsl.rb'

data/lib/dao/api/context.rb

@@ -1,38 +1,63 @@
 module Dao
   class Context
-    Attrs = %w( api interface params result method args )
-    Attrs.each{|attr| attr_accessor(attr)}
+    Attrs = %w( api route path interface method args status errors params result data form validations )
 
-    def initialize(*args, &block)
+    Attrs.each{|a| attr_accessor(a)}
+
+    def Context.attrs
+      Attrs
+    end
+
+    def Context.for(api, route, path, interface, params, *args)
+    # setup
+    #
       options = Dao.options_for!(args)
 
-      api = options[:api]
-      interface = options[:interface]
-      params = options[:params]
-    
-      params = Params.for(:api => api, :interface => interface, :params => params)
-      result = Result.new(:api => api, :interface => interface, :params => params)
-      params.result = result
+      parsed_params = Dao.parse(path, params, options)
+
+      result = Result.new(:mode => api.mode)
+      params = result.params
+      params.update(parsed_params)
 
       method = interface.method.bind(api)
       args = [params, result].slice(0, method.arity)
 
-      self.api = api
-      self.interface = interface
-      self.params = params
-      self.result = result
-      self.method = method
-      self.args = args
-    end
+    # build the context
+    #
+      context = new
+      context.api = api
+      context.interface = interface
+      context.route = route
+      context.path = path
+      context.method = method
+      context.args = args
+      context.status = Status.default
+      context.errors = Errors.new
 
-    def call()
-      method.call(*args)
+      context.result = result
+      context.data = result.data
+
+      context.params = params
+      context.form = params.form
+      context.validations = params.validations
+
+    # wire up shared state
+    #
+      result.route = context.route
+      result.path = context.path
+      result.status = context.status
+      result.errors = context.errors
+
+      params.route = context.route
+      params.path = context.path
+      params.status = context.status
+      params.errors = context.errors
+
+      context
     end
 
-    def update(options = {})
-      options.each do |key, val|
-        send("#{ key }=", val)
-      end
+    def call
+      method.call(*args)
     end
   end
 end

data/lib/dao/api/dsl.rb

@@ -19,7 +19,7 @@ module Dao
         raise "no interface for #{ docs.inspect }" unless docs.empty?
       end
 
-      %w( interface doc docs description desc ).each do |method|
+      %w( interface call doc docs description desc ).each do |method|
         module_eval <<-__, __FILE__, __LINE__ - 1
 
           def #{ method }(*args, &block)

data/lib/dao/api/interfaces.rb

@@ -1,5 +1,7 @@
 module Dao
   class Api
+  # class methods
+  #
     class << Api
       def interfaces
         @interfaces ||= Map.new
@@ -9,23 +11,24 @@ module Dao
         api = self
         path = Path.new(path)
 
+        route = routes.add(path) if Route.like?(path)
+
         method =
           module_eval{ 
             define_method(path + '/interface', &block)
             instance_method(path + '/interface')
           }
 
-
         interface = Interface.new(
           'api' => api,
           'path' => path,
+          'route' => route,
           'method' => method,
           'doc' => docs.pop
         )
 
         interfaces[path] = interface
       end
-
       alias_method('call', 'interface')
 
       def description(string)
@@ -51,197 +54,226 @@ module Dao
       def index
         index = Map.new
         interfaces.each do |path, interface|
-          index[path] = interface.doc || {'description' => path}
+          index[path] = interface.doc || {'description' => ''}
         end
         index
       end
     end
 
+# instance methods
+#
+
+
+  # call support 
+  #
     def call(path = '/index', params = {}, options = {})
       api = self
       path = Path.new(path)
-      interface = interfaces[path]
+      interface = interfaces[path]  ### interfaces.by_path(path)
+      route = nil
+
+      unless interface
+        route = route_for(path)
+        interface = interfaces[route]
+      end
 
       unless interface
         return index if path == '/index'
         raise(NameError, "NO SUCH INTERFACE: #{ path }")
       end
 
-      options = Map.options(options || {})
-
-      params = Dao.parse(path, params, options)
+      if route
+        params.update(route.params_for(path))
+        path = route.path_for(params)
+      else
+        if Route.like?(path)
+          route = Route.new(path)
+          path = route.path_for(params)
+        end
+      end
 
-      context = Context.new(
-        :api => api,
-        :interface => interface,
-        :params => params
-      )
+      context = Context.for(api, route, path, interface, params, options)
 
       callstack(context) do
-        catching(:result){ context.call() }
+        catching(:result) do
+          context.call()
+        end
       end
 
       context.result
     end
 
-    def index
-      result = Result.new('/index')
-      result.data.update(self.class.index)
-      result
+  # lookup a route
+  #
+    def route_for(*args)
+      self.class.routes.match(*args)
     end
 
-    def interfaces
-      self.class.interfaces
+  # context support
+  #
+    def callstack(context = nil, &block)
+      @callstack ||= []
+
+      if block and context
+        begin
+          @callstack.push(context)
+          return block.call()
+        ensure
+          @callstack.pop
+        end
+      else
+        @callstack
+      end
     end
 
     def context
       callstack.last || raise('no context!')
     end
 
-    def result
-      context.result
+    def context?
+      !!callstack.last
     end
 
-    def params
-      result.params
+    def catching(label = :result, &block)
+      @catching ||= []
+
+      if block
+        begin
+          @catching.push(label)
+          catch(label, &block)
+        ensure
+          @catching.pop
+        end
+      else
+        @catching.last
+      end
     end
 
-    def errors
-      result.errors
+    def return!(*value)
+      throw(:result, *value)
     end
 
-    def apply(hash = {})
-      data.apply(hash)
+    def catching_results(&block)
+      catching(:result, &block)
     end
 
-    def update(hash = {})
-      data.update(hash)
+    def catching?
+      catching
     end
 
-    def default(*args)
-      hash = Map.options_for!(args)
-      if hash.empty?
-        value = args.pop
-        key = args
-        hash = {key => value}
-      end
-      data.apply(hash)
+    def catching_results?
+      catching == :result
     end
 
-    def status(*args, &block)
-      result.status(*args, &block)
+  # delgate some methods to the context
+  #
+    Context.attrs.each do |method|
+      module_eval <<-__, __FILE__, __LINE__
+        def #{ method }(*args)
+          context.send(#{ method.inspect }, *args)
+        end
+      __
     end
 
-    def status!(*args, &block)
-      status(*args, &block)
+    def status(*args)
+      context.status.update(*args) unless args.empty?
+      context.status
+    end
+    def status!(*args)
+      status.update(*args)
       return!
     end
 
     def data(*args)
-      if args.empty?
-        result.data
-      else
-        result.data.replace(*args)
-      end
+      context.data.replace(*args) unless args.empty?
+      context.data
     end
-
     def data!(*args)
-      result.data.replace(*args)
+      data(*args)
       valid!
     end
 
-    def update(*args, &block)
-      data.update(*args, &block)
-    end
-
-    def replace(*args, &block)
-      data.replace(*args, &block)
-    end
-
-    def validations
-      result.validations
+    def params!(*args)
+      params.replace(*args)
+      valid!
     end
 
-    def validates(*args, &block)
-      result.validates(*args, &block)
+    def error!
+      result.error!
     end
 
-    def validate
-      result.validate
+  # 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 valid?
-      result.valid?
+  # misc
+  #
+    def index
+      self.class.index
     end
 
-    def validate!
-      result.validate!
+    def interfaces
+      self.class.interfaces
     end
 
-    def valid!
-      result.valid!
+    def respond_to?(*args)
+      super(*args) || super(Path.absolute_path_for(*args))
     end
 
-    include Validations::Common
-
-    def return!(*value)
-      throw(:result, *value)
-    end
+  # immediate parameter parsing support
+  #
+    def parameter(*args, &block)
+      options = Map.options_for!(args)
 
-=begin
-    def set(*args, &block)
-      result.data.set(*args, &block)
-    end
+      keys = args + Array(options[:keys]) + Array(options[:or])
 
-    def get(*args, &block)
-      params.data.get(*args, &block)
-    end
-=end
+      raise(ArgumentError, 'no keys') if keys.empty?
 
-    def callstack(context = nil, &block)
-      @callstack ||= []
+      blank = Object.new.freeze
+      value = blank
 
-      if block and context
-        begin
-          @callstack.push(context)
-          return block.call()
-        ensure
-          @callstack.pop
+      keys.each do |key|
+        if params.has?(key)
+          value = params.get(key)
+          break unless value.to_s.strip.empty?
         end
-      else
-        @callstack
       end
-    end
 
-    def catching(label = :result, &block)
-      @catching ||= []
-
-      if block
-        begin
-          @catching.push(label)
-          catch(label, &block)
-        ensure
-          @catching.pop
-        end
-      else
-        @catching.last
+      if value == blank
+        message =
+          case options[:error]
+            when nil, false
+              nil
+            when true
+              which = keys.map{|key| Array(key).join('.')}.join(' or ')
+              "#{ which } (parameter is blank)"
+            else
+              message = options[:error].to_s
+          end
+        errors.add(message) if message
+
+        status(options[:status]) if options[:status]
+        return! if options[:return!]
       end
-    end
 
-    def catching_results(&block)
-      catching(:result, &block)
-    end
-
-    def catching?
-      catching
+      value == blank ? nil : value
     end
+    alias_method('param', 'parameter')
 
-    def catching_results?
-      catching == :result
-    end
-
-    def respond_to?(*args)
-      super(*args) || super(Path.absolute_path_for(*args))
+    def parameter!(*args, &block)
+      options = args.last.is_a?(Hash) ? Map.for(args.pop) : Map.new
+      args.push(options)
+      options[:error] = true unless options.has_key?(:error)
+      options[:return!] = true unless options.has_key?(:return!)
+      options[:status] = 412 unless options.has_key?(:status)
+      parameter(*args, &block)
     end
+    alias_method('param!', 'parameter!')
   end
 end