pakyow-core 0.8.rc4 → 0.8.0

data/pakyow-core/lib/core/response.rb

@@ -2,5 +2,17 @@ module Pakyow
 
   # The Response object.
   class Response < Rack::Response
+    attr_reader :format
+
+    def initialize(*args)
+      super
+
+      self["Content-Type"] ||= 'text/html'
+    end
+
+    def format=(format)
+      @format = format
+      self["Content-Type"] = Rack::Mime.mime_type(".#{format}")
+    end
   end
 end

data/pakyow-core/lib/core/route_eval.rb

@@ -1,84 +1,65 @@
 module Pakyow
   class RouteEval
-    attr_reader :path
-
-    def initialize(path = '/', hooks = { :before => [], :after => []}, fns = {}, group_name = nil, namespace = false)
-      @path = path
-      @scope  = {:path => path, :hooks => hooks, :group_name => group_name, :namespace => namespace}
-      @routes = {:get => [], :post => [], :put => [], :delete => []}
-      @lookup = {:routes => {}, :grouped => {}}
-      @fns  = fns
-      @groups = {}
-      @templates = {}
-      @handlers = []
-
-      eval(&RouteTemplateDefaults.defaults)
-    end
+    include RouteMerger
 
-    def eval(template = false, &block)
-      # if we're evaling a template, need to push
-      # member routes to the end (they're always
-      # created first, but need to be the last out)
-      if template
-        @member_routes = @routes
-        @routes = {:get => [], :post => [], :put => [], :delete => []}
-      end
+    attr_reader :path, :fns, :hooks, :group, :routes, :handlers, :lookup, :templates
 
-      instance_exec(&block)
+    HTTP_METHODS   = [:get, :post, :put, :patch, :delete]
+    DEFAULT_MIXINS = ['Restful']
 
-      if template
-        merge_routes(@routes, @member_routes)
-      end
-    end
+    class << self
+      def with_defaults(*args)
+        instance = self.new(*args)
 
-    def merge(fns, routes, handlers, lookup)
-      # routes.merge!(@routes)
-      merge_routes(routes, @routes)
-      handlers.concat(@handlers)
-      # lookup.merge!(@lookup)
-      fns.merge!(@fns)
+        # Mixin defaults
+        DEFAULT_MIXINS.each { |mixin| instance.include(Pakyow::Routes.const_get(mixin)) }
 
-      merge_lookup(lookup, @lookup)
+        return instance
+      end
 
-      return fns, routes, handlers, lookup
-    end
+      def from_scope(route_eval, overrides = {})
+				args = [:path, :fns, :hooks, :templates, :group].inject([]) do |acc, arg|
+					acc << (overrides.fetch(arg) { route_eval.send(arg) })
+				end
 
-    # Creates or retreives a named route function. When retrieving,
-    #
-    def fn(name, &block)
-      @fns[name] = block and return if block
-      @fns[name]
+        instance = self.new(*args)
+      end
     end
 
-    # def action(name, &block)
-    #   @fns[name] = block and return if block
-    #   @fns[name]
-    # end
-
-    def action(method, *args, &block)
-      fn, hooks = self.class.parse_action_args(args)
-      fns = block_given? ? [block] : [fn]
-      @fns[method] = build_fns(fns, hooks)
-    end
+    def initialize(path = '/', fns = nil, hooks = nil, templates = nil, group = nil)
+      @path      = path
+      @fns       = fns || {}
+      @routes    = HTTP_METHODS.inject({}) { |acc, m| acc[m] = []; acc }
+      @hooks     = hooks || { before: [], after: [] }
+      @templates = templates || {}
+      @group     = group
 
-    def default(*args, &block)
-      register_route(:get, '/', :default, *args, &block)
+      @lookup    = { routes: {}, grouped: {} }
+      @handlers  = []
     end
 
-    def get(*args, &block)
-      register_route(:get, *args, &block)
+    # Path for evals within this eval
+    #
+    def descendent_path
+      @descendent_path || @path
     end
 
-    def put(*args, &block)
-      register_route(:put, *args, &block)
+    def include(route_module)
+      merge(route_module.route_eval)
     end
 
-    def post(*args, &block)
-      register_route(:post, *args, &block)
+    def eval(&block)
+      instance_exec(&block)
     end
 
-    def delete(*args, &block)
-      register_route(:delete, *args, &block)
+    # Creates or retreives a named route function. When retrieving,
+    #
+    def fn(name, &block)
+      if block_given?
+        @fns[name] = block
+      else
+        @fns[name]
+      end
     end
 
     # Creates a handler.
@@ -98,81 +79,68 @@ module Pakyow
     def group(*args, &block)
       name, hooks = self.class.parse_group_args(args)
 
-      evaluator = RouteEval.new(@scope[:path], merge_hooks(hooks, @scope[:hooks]), @fns, name)
+      evaluator = RouteEval.from_scope(self, path: descendent_path, group: name, hooks: hooks)
       evaluator.eval(&block)
 
-      @fns, @routes, @handlers, @lookup = evaluator.merge(@fns, @routes, @handlers, @lookup)
+      merge(evaluator)
     end
 
     def namespace(*args, &block)
       path, name, hooks = self.class.parse_namespace_args(args)
 
-      #TODO shouldn't this be in parse_namespace_args?
-      hooks = name if name.is_a?(Hash)
-
-      evaluator = RouteEval.new(File.join(@scope[:path], path), merge_hooks(hooks, @scope[:hooks]), @fns, name, true)
+      evaluator = RouteEval.from_scope(self, path: File.join(descendent_path, path), group: name, hooks: hooks)
       evaluator.eval(&block)
 
-      @fns, @routes, @handlers, @lookup = evaluator.merge(@fns, @routes, @handlers, @lookup)
+      merge(evaluator)
     end
 
     def template(*args, &block)
       name, hooks = self.class.parse_template_args(args)
+
       @templates[name] = [hooks, block]
     end
 
-    def expand(t_name, g_name, *args, &block)
+    def expand(t_name, g_name = nil, *args, &block)
       path, hooks = self.class.parse_expansion_args(args)
+      path ||= ''
 
       template = @templates[t_name]
 
-      evaluator = RouteEval.new(File.join(@scope[:path], path), merge_hooks(merge_hooks(hooks, @scope[:hooks]), template[0]), @fns, g_name, true)
+      evaluator = RouteExpansionEval.from_scope(self, path: File.join(descendent_path, path), group: g_name, hooks: hooks)
+			evaluator.direct_path = path
+      evaluator.template = template
       evaluator.eval(&block)
-      evaluator.eval(true, &template[1])
 
-      @fns, @routes, @handlers, @lookup = evaluator.merge(@fns, @routes, @handlers, @lookup)
+      merge(evaluator)
     end
 
-    protected
-
-    def merge_hooks(h1, h2)
-      # normalize
-      h1 = normalize_hooks(h1)
-      h2 = normalize_hooks(h2)
-
-      # merge
-      h1[:before].concat(h2[:before])
-      h1[:after].concat(h2[:after])
-      h1[:around].concat(h2[:around])
-
-      return h1
+    def default(*args, &block)
+      build_route(:get, '/', :default, *args, &block)
     end
 
-    def merge_routes(r1, r2)
-      r1[:get].concat(r2[:get])
-      r1[:put].concat(r2[:put])
-      r1[:post].concat(r2[:post])
-      r1[:delete].concat(r2[:delete])
-
-      return r1
+    HTTP_METHODS.each do |method|
+      define_method method do |*args, &block|
+        build_route(method, *args, &block)
+      end
     end
 
-    def merge_lookup(l1, l2)
-      l1[:routes].merge!(l2[:routes])
-      l1[:grouped].merge!(l2[:grouped])
-
-      return l1
+    # For the expansion of templates
+    def method_missing(method, *args, &block)
+      if template_defined?(method)
+        expand(method, *args, &block)
+      else
+        super
+        # action(method, *args, &block)
+      end
     end
 
-    def copy_hooks(hooks)
-      {
-        :before => (hooks[:before] || []).dup,
-        :after => (hooks[:after] || []).dup,
-        :around => (hooks[:around] || []).dup,
-      }
+    def template_defined?(template)
+      !@templates[template].nil?
     end
 
-    def register_route(method, *args, &block)
+    protected
+
+		def build_route(method, *args, &block)
       path, name, fns, hooks = self.class.parse_route_args(args)
 
       fns ||= []
@@ -180,7 +148,7 @@ module Pakyow
       fns << block if block_given?
 
       # merge route hooks with scoped hooks
-      hooks = merge_hooks(hooks || {}, @scope[:hooks])
+      hooks = merge_hooks(hooks || {}, @hooks)
 
       # build the final list of fns
       fns = build_fns(fns, hooks)
@@ -190,28 +158,26 @@ module Pakyow
         vars  = []
       else
         # prepend scope path if we're in a scope
-        path = File.join(@scope[:path], path)
-        path = StringUtils.normalize_path(path)
+        path = File.join(@path, path)
+        path = Utils::String.normalize_path(path)
 
         # get regex and vars for path
         regex, vars = build_route_matcher(path)
       end
 
-      # create the route tuple
-      route = [regex, vars, name, fns, path]
-
-      @routes[method] << route
+			register_route([regex, vars, name, fns, path, method])
+		end
 
-      # add route to lookup, unless it's namespaced (because
-      # then it can only be accessed through the grouping)
-      unless namespace?
-        @lookup[:routes][name] = route
-      end
+    def register_route(route)
+      @routes[route[5]] << route
 
-      # add to grouped lookup, if we're in a group
       if group?
-        (@lookup[:grouped][@scope[:group_name]] ||= {})[name] = route
+        bucket = (@lookup[:grouped][@group] ||= {})
+      else
+        bucket = @lookup[:routes]
       end
+
+			bucket[route[2]] = route
     end
 
     def build_route_matcher(path)
@@ -236,30 +202,7 @@ module Pakyow
     end
 
     def group?
-      !@scope[:group_name].nil?
-    end
-
-    def namespace?
-      @scope[:namespace]
-    end
-
-    # yields current path to the block for modification,
-    # then updates paths for member routes
-    def nested_path
-      new_path = yield(@scope[:group_name], @path)
-
-      # update paths of member routes
-      @member_routes.each {|type,routes|
-        routes.each { |route|
-          path = StringUtils.normalize_path(File.join(new_path, route[4].gsub(/^#{StringUtils.normalize_path(@path)}/, '')))
-          regex, vars = build_route_matcher(path)
-          route[0] = regex
-          route[1] = vars
-          route[4] = path
-        }
-      }
-
-      @path = new_path
+      !@group.nil?
     end
 
     def build_fns(main_fns, hooks)
@@ -273,22 +216,6 @@ module Pakyow
       fns
     end
 
-    def normalize_hooks(hooks)
-      hooks ||= {}
-
-      [:before, :after, :around].each do |type|
-        # force array
-        hooks[type] = Array(hooks[type])
-
-        # lookup hook fns if not already a Proc
-        hooks[type] = hooks[type].map do |hook|
-          hook.is_a?(Symbol) ? fn(hook) : hook
-        end
-      end
-
-      return hooks
-    end
-
     class << self
       def parse_route_args(args)
         ret = []
@@ -373,7 +300,82 @@ module Pakyow
         }
         ret
       end
+    end
+  end
+
+  class RouteExpansionEval < RouteEval
+    attr_writer :direct_path
 
+    def eval(&block)
+      @template_eval = RouteTemplateEval.from_scope(self, path: path, group: @group, hooks: @hooks)
+			@template_eval.direct_path = @direct_path
+			@template_eval.eval(&@template_block)
+
+			@path = @template_eval.routes_path
+
+      super
+    end
+
+    def template=(template)
+      @template_block = template[1]
+
+      @hooks = merge_hooks(@hooks, template[0])
+    end
+
+    def action(method, *args, &block)
+      fn, hooks = self.class.parse_action_args(args)
+			fn = block if block_given?
+
+			# get route info from template
+			route = @template_eval.route_for_action(method)
+
+			all_fns = route[3]
+			all_fns[:fns].unshift(fn) if fn
+
+			hooks = merge_hooks(hooks, all_fns[:hooks])
+			route[3] = build_fns(all_fns[:fns], hooks)
+
+			register_route(route)
+    end
+
+		def action_group(*args, &block)
+      name, hooks = self.class.parse_action_group_args(args)
+			group = @template_eval.group_named(name)
+
+			hooks = merge_hooks(hooks, group[0])
+			group(name, hooks, &block)
+		end
+
+		def action_namespace(*args, &block)
+      name, hooks = self.class.parse_action_namespace_args(args)
+			namespace = @template_eval.namespace_named(name)
+
+			hooks = merge_hooks(hooks, namespace[1])
+			namespace(name, namespace[0], hooks, &block)
+		end
+
+    def method_missing(method, *args, &block)
+			if @template_eval.has_action?(method)
+				action(method, *args, &block)
+			elsif @template_eval.has_namespace?(method)
+				action_namespace(method, *args, &block)
+			elsif @template_eval.has_group?(method)
+				action_group(method, *args, &block)
+			else
+				super
+			end
+		rescue NoMethodError
+			raise UnknownTemplatePart, "No action, namespace, or group named '#{method}'"
+    end
+
+		def expand(*args, &block)
+			args[2] = File.join(@template_eval.nested_path.gsub(@path, ''), args[2])
+			super(*args, &block)
+		end
+
+		private
+
+		class << self
       def parse_action_args(args)
         ret = []
         args.each { |arg|
@@ -385,6 +387,97 @@ module Pakyow
         }
         ret
       end
-    end
+
+      def parse_action_namespace_args(args)
+        ret = []
+        args.each { |arg|
+          if arg.is_a?(Hash) # we have hooks
+            ret[1] = arg
+          elsif arg.is_a?(Symbol) # we have a name
+            ret[0] = arg
+          end
+        }
+        ret
+      end
+
+      def parse_action_group_args(args)
+        ret = []
+        args.each { |arg|
+          if arg.is_a?(Hash) # we have hooks
+            ret[1] = arg
+          elsif !arg.nil? # we have a name
+            ret[0] = arg
+          end
+        }
+        ret
+      end
+		end
+  end
+
+  class RouteTemplateEval < RouteEval
+		attr_accessor :direct_path
+
+		def initialize(*args)
+			super
+
+			@groups = {}
+			@namespaces = {}
+
+			@routes_path = path
+			@nested_path = path
+		end
+
+		def has_action?(name)
+		 	!route_for_action(name).nil?
+		end
+
+		def has_group?(name)
+			!group_named(name).nil?
+		end
+
+		def has_namespace?(name)
+			!namespace_named(name).nil?
+		end
+
+		def route_for_action(name)
+			lookup.fetch(:grouped, {}).fetch(@group, {})[name]
+		end
+
+		def namespace_named(name)
+			@namespaces[name]
+		end
+
+		def group_named(name)
+			@groups[name]
+		end
+
+		def build_fns(fns, hooks)
+			{
+				fns: fns,
+				hooks: hooks,
+			}
+		end
+
+		def namespace(*args)
+      path, name, hooks = self.class.parse_namespace_args(args)
+			@namespaces[name] = [path, hooks]
+		end
+
+		def group(*args)
+      name, hooks = self.class.parse_group_args(args)
+			@groups[name] = [hooks]
+		end
+
+		def routes_path(&block)
+			return @routes_path unless block_given?
+			@routes_path = yield(@routes_path)
+			@path = @routes_path
+		end
+
+		def nested_path(&block)
+			return @nested_path unless block_given?
+			@nested_path = yield(@nested_path)
+		end
   end
 end
+