pakyow-core 0.8.rc4 → 0.8.0

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

@@ -7,9 +7,8 @@ module Pakyow
     include Helpers
 
     def path(name, data = nil)
-      if route = get_named_route(name)
-        data ? populate(route, data) : File.join('/', route[4])
-      end
+      route = get_named_route(name)
+      data ? populate(route, data) : File.join('/', route[4])
     end
 
     def group(name)
@@ -29,9 +28,9 @@ module Pakyow
 
     def populate(route, data = {})
       vars  = route[1]
-      
+
       split_path = Request.split_url(route[4])
-      
+
       vars.each {|v|
         split_path[v[:url_position]] = data.delete(v[:var])
       }

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

@@ -0,0 +1,76 @@
+module Pakyow
+  module RouteMerger
+    private 
+
+    def merge(route_eval)
+      merge_fns(route_eval.fns)
+      merge_routes(route_eval.routes)
+      merge_handlers(route_eval.handlers)
+      merge_lookup(route_eval.lookup)
+      merge_templates(route_eval.templates)
+    end
+
+    def merge_fns(fns)
+      @fns.merge!(fns)
+    end
+
+    def merge_routes(routes)
+      @routes[:get].concat(routes[:get])
+      @routes[:put].concat(routes[:put])
+      @routes[:patch].concat(routes[:patch])
+      @routes[:post].concat(routes[:post])
+      @routes[:delete].concat(routes[:delete])
+    end
+
+    def merge_handlers(handlers)
+      @handlers.concat(handlers)
+    end
+
+    def merge_lookup(lookup)
+      @lookup[:routes].merge!(lookup[:routes])
+      @lookup[:grouped].merge!(lookup[:grouped])
+    end
+
+    def merge_templates(templates)
+      @templates.merge!(templates)
+    end
+
+    #TODO should this accept one or two args?
+    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
+    end
+
+    def copy_hooks(hooks)
+      {
+        :before => (hooks[:before] || []).dup,
+        :after => (hooks[:after] || []).dup,
+        :around => (hooks[:around] || []).dup,
+      }
+    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
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'forwardable'
+
+module Pakyow
+  # Include in a module to define route mixins
+  # that can be included into route sets.
+  module Routes
+    def self.included(base)
+      raise StandardError, "Pakyow::Routes is intended to be included only in other modules" if base.is_a?(Class)
+
+      base.extend(ClassMethods)
+      base.instance_variable_set(:@route_eval, RouteEval.new)
+    end
+
+    module ClassMethods
+      attr_reader :route_eval
+      extend Forwardable
+      def_delegators :@route_eval, :fn, :default, :get, :put, :post, :delete,
+                     :handler, :group, :namespace, :template, :action, :expand
+    end
+  end
+end

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

@@ -1,28 +1,35 @@
 module Pakyow
   class RouteSet
+    include RouteMerger
+
     attr_reader :routes, :lookup
 
     def initialize
-      @routes = {:get => [], :post => [], :put => [], :delete => []}
+      @routes = {:get => [], :post => [], :put => [], :patch => [], :delete => []}
       @lookup = { :routes => {}, :grouped => {}}
       @handlers = []
       @fns = {}
+      @templates = {}
     end
 
     def eval(&block)
-      evaluator = RouteEval.new
+      evaluator = RouteEval.with_defaults
       evaluator.eval(&block)
-
-      @fns, @routes, @handlers, @lookup = evaluator.merge(@fns, @routes, @handlers, @lookup)
+      merge(evaluator)
     end
 
     # Returns a route tuple:
     # [regex, vars, name, fns, path]
     #
     def match(path, method)
-      path = StringUtils.normalize_path(path)
+      path = Utils::String.normalize_path(path)
 
-      @routes[method.to_sym].each{|r|
+      # want the request to still knows it's a head, but match as get
+      method = method.to_sym
+      method = :get if method == :head
+
+      @routes[method].each{|r|
+        #TODO can we do this without conditionals? fall-through?
         case r[0]
         when Regexp
           if data = r[0].match(path)
@@ -43,6 +50,7 @@ module Pakyow
         return h if h[0] == name_or_code || h[1] == name_or_code
       }
 
+      #TODO raise error
       nil
     end
 
@@ -53,11 +61,10 @@ module Pakyow
       if grouped_routes = @lookup[:grouped][group]
         return grouped_routes[name]
       else
-        #TODO error
+        #TODO error (perhaps a set-specific exception rescued by router)
       end
     end
 
-
     # Name based fn lookup
     def fn(name)
       return @fns[name]

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

@@ -1,35 +1,33 @@
 module Pakyow
-  class RouteTemplateDefaults
-    def self.defaults
-      lambda {
-        template(:restful) {
-          unnested_path = path.dup
-          nested_path { |group, path|
-            File.join(path, ":#{group}_id")
-          }
-
-          default fn(:default) if fn(:default)
-
-          get '/new', :new, fn(:new) if fn(:new)
-          
-          # special case for show (view path is overridden)
-          if show_fns = fn(:show)
-            get '/:id', :show, Array(show_fns).unshift(
-              lambda {
-                #TODO would like to move this reference out of core
-                presenter.view_path = File.join(unnested_path, 'show') if @presenter
-              }
-            )
-          end
-          
-          post '/', :create, fn(:create) if fn(:create)
-
-          get '/:id/edit', :edit, fn(:edit) if fn(:edit)
-          put '/:id', :update, fn(:update) if fn(:update)
-
-          delete '/:id', :delete, fn(:delete) if fn(:delete)
-        }
-      }
+  module Routes
+    module Restful
+      include Pakyow::Routes
+
+      template :restful do
+        resource_id = ":#{@group}_id"
+
+        nested_path { |path| File.join(path, resource_id) }
+        view_path = direct_path.gsub(/:[^\/]+/, '').split('/').reject { |p| p.empty? }.join('/')
+
+        fn :reset_view_path do
+          presenter.path = File.join(view_path, 'show') if @presenter
+        end
+
+        get :list, '/'
+        get :new,  '/new'
+        get :show, "/#{resource_id}", before: [:reset_view_path]
+
+        post :create, '/'
+
+        get :edit, "/#{resource_id}/edit"
+        patch :update, "/#{resource_id}"
+        put :replace, "/#{resource_id}"
+        delete :delete, "/#{resource_id}"
+
+        group :collection
+        namespace :member, resource_id
+      end
+
     end
   end
 end

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

@@ -34,16 +34,16 @@ module Pakyow
         end
       }
 
-      nil
+      raise MissingRoute, "Could not find route '#{name}'"
     end
 
     # Performs the initial routing for a request.
     #
-    def perform(request, ctx = Pakyow.app, &after_match)
-      fns = match(request)
+    def perform(context, app = Pakyow.app, &after_match)
+      fns = match(context.request)
       after_match.call if block_given?
 
-      trampoline(fns, ctx)
+      trampoline(fns, app)
     end
 
     # Reroutes a request.
@@ -80,10 +80,15 @@ module Pakyow
 
     # Calls a defined fn
     #
-    def fn(name)
+    def fn(name, app = nil)
       @sets.each { |set|
         if fn = set[1].fn(name)
-          fn.call
+          if app.nil?
+            fn.call
+          else
+            app.instance_exec(&fn)
+          end
+          
           break
         end
       }
@@ -101,7 +106,7 @@ module Pakyow
     # returns the list of route functions for that route.
     #
     def match(request)
-      path   = StringUtils.normalize_path(request.path)
+      path   = Utils::String.normalize_path(request.path)
       method = request.method
 
       match, data = nil
@@ -116,7 +121,7 @@ module Pakyow
 
         # handle route params
         #TODO where to do this?
-        request.params.merge!(HashUtils.strhash(self.data_from_path(path, data, match[1])))
+        request.params.merge!(Utils::Hash.strhash(self.data_from_path(path, data, match[1])))
 
         #TODO where to do this?
         request.route_path = match[4]
@@ -128,11 +133,11 @@ module Pakyow
     # Calls route functions and catches new functions as
     # they're thrown (e.g. by reroute).
     #
-    def trampoline(fns, ctx)
+    def trampoline(fns, app)
       routed = false
       until fns.empty?
         fns = catch(:fns) {
-          self.call_fns(fns, ctx)
+          self.call_fns(fns, app)
 
           # Getting here means that call() returned normally (not via a throw)
           :fall_through

data/pakyow-core/lib/utils/dir.rb

@@ -1,12 +1,13 @@
 module Pakyow
+  module Utils
 
   # Utility methods for directories and files.
-  class DirUtils
+    class Dir
 
       # visit dir, then all files in dir, then walk_dir each directory in dir
       def self.walk_dir(dir, &block)
         yield dir
-        all = Dir.entries(dir)
+        all = ::Dir.entries(dir)
         partition = all.partition{|e| File.file?("#{dir}/#{e}")}
         files = partition[0]
         dirs = partition[1]
@@ -16,7 +17,7 @@ module Pakyow
 
       def self.print_dir(dir)
         puts "/#{dir}"
-        DirUtils.walk_dir(dir) {|full_path|
+        Utils::Dir.walk_dir(dir) {|full_path|
           path = full_path.gsub(Regexp.new("#{dir}\/?"), '')
           next if path.empty?
 
@@ -33,5 +34,7 @@ module Pakyow
       def self.dir_within_dir?(dir1, dir2)
         (dir1.split('/') - dir2.split('/')).empty?
       end
+    end
+
   end
 end

data/pakyow-core/lib/utils/hash.rb

@@ -1,41 +1,44 @@
 module Pakyow
+  module Utils
 
-  # Utility methods for hashes.
-  class HashUtils
-    # Creates an indifferent hash. This means that when indifferentized, this hash:
-    #   { 'foo' => 'bar' }
-    #
-    # Can be accessed like this:
-    #   { :foo => 'bar' }
-    #
-    def self.strhash(hash)
-      indifferentize(hash)
-    end
+    # Utility methods for hashes.
+    class Hash
+      # Creates an indifferent hash. This means that when indifferentized, this hash:
+      #   { 'foo' => 'bar' }
+      #
+      # Can be accessed like this:
+      #   { :foo => 'bar' }
+      #
+      def self.strhash(hash)
+        indifferentize(hash)
+      end
 
-    # Converts keys to symbols.
-    def self.symbolize_keys(hash)
-      Hash[hash.map{|(k,v)| [k.to_sym,v]}]
-    end
+      # Converts keys to symbols.
+      def self.symbolize_keys(hash)
+        ::Hash[hash.map{|(k,v)| [k.to_sym,v]}]
+      end
 
-    # Converts keys/values to symbols.
-    def self.symbolize(hash)
-      Hash[hash.map{|(k,v)| [k.to_sym,v.to_sym]}]
-    end
+      # Converts keys/values to symbols.
+      def self.symbolize(hash)
+        ::Hash[hash.map{|(k,v)| [k.to_sym,v.to_sym]}]
+      end
+
+      protected
 
-    protected
+      # (see {strhash})
+      def self.indifferentize(hash)
+        hash.each_pair do |key, value|
+          hash[key] = indifferentize(value) if value.is_a? ::Hash
+        end
 
-    # (see {strhash})
-    def self.indifferentize(hash)
-      hash.each_pair do |key, value|
-        hash[key] = indifferentize(value) if value.is_a? Hash
+        indifferent_hash.merge(hash)
       end
 
-      indifferent_hash.merge(hash)
+      # (see {strhash})
+      def self.indifferent_hash
+        ::Hash.new { |hash,key| hash[key.to_s] if Symbol === key }
+      end
     end
 
-    # (see {strhash})
-    def self.indifferent_hash
-      Hash.new { |hash,key| hash[key.to_s] if Symbol === key }
-    end
   end
 end

data/pakyow-core/lib/utils/string.rb

@@ -1,37 +1,40 @@
 module Pakyow
+  module Utils
 
-  # Utility methods for strings.
-  class StringUtils
+    # Utility methods for strings.
+    class String
 
-    # split . seperated string at the last .
-    def self.split_at_last_dot(s)
-      split_index = s.rindex('.')
-      return s,nil unless split_index
-      left = s[0,split_index]
-      right = s[split_index+1,s.length-(split_index+1)]
-      return left,right
-    end
+      # split . seperated string at the last .
+      def self.split_at_last_dot(s)
+        split_index = s.rindex('.')
+        return s,nil unless split_index
+        left = s[0,split_index]
+        right = s[split_index+1,s.length-(split_index+1)]
+        return left,right
+      end
 
-    def self.remove_route_vars(route_spec)
-      return unless route_spec
-      arr = route_spec.split('/')
-      new_arr = []
-      arr.each {|e| new_arr << e unless e[0,1] == ':'}
-      ret = new_arr.join('/')
-      return '/' if ret == ''
-      return ret
-    end
+      def self.remove_route_vars(route_spec)
+        return unless route_spec
+        arr = route_spec.split('/')
+        new_arr = []
+        arr.each {|e| new_arr << e unless e[0,1] == ':'}
+        ret = new_arr.join('/')
+        return '/' if ret == ''
+        return ret
+      end
 
-    def self.parse_path_from_caller(caller)
-      caller.match(/^(.+)(:?:\d+(:?:in `.+')?$)/)[1]
-    end
+      def self.parse_path_from_caller(caller)
+        caller.match(/^(.+)(:?:\d+(:?:in `.+')?$)/)[1]
+      end
+
+      def self.normalize_path(path)
+        return path if path.is_a?(Regexp)
 
-    def self.normalize_path(path)
-      return path if path.is_a?(Regexp)
+        path = path[1, path.length - 1] if path[0, 1] == '/'
+        path = path[0, path.length - 1] if path[path.length - 1, 1] == '/'
+        path
+      end
 
-      path = path[1, path.length - 1] if path[0, 1] == '/'
-      path = path[0, path.length - 1] if path[path.length - 1, 1] == '/'
-      path
     end
 
   end