pakyow-core 0.7.2 → 0.8rc1

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

@@ -0,0 +1,260 @@
+module Pakyow
+  class RouteSet
+    def initialize
+      @routes = {:get => [], :post => [], :put => [], :delete => []}
+
+      @routes_by_name = {}
+      @grouped_routes_by_name = {}
+
+      @fns  = {}
+      @groups = {}
+
+      @templates = {}
+
+      @handlers = []
+
+      @scope  = {:name => nil, :path => '/', :hooks => {:before => [], :after => []}}
+    end
+
+    # Creates or retreives a named route function. When retrieving, 
+    #
+    def fn(name, &block)
+      @fns[name] = block and return if block
+
+      #TODO rewrite to not return array
+      [@fns[name]]
+    end
+
+    def default(*args, &block)
+      self.register_route(:get, '/', *args, &block)
+    end
+
+    def get(*args, &block)
+      self.register_route(:get, *args, &block)
+    end
+
+    def put(*args, &block)
+      self.register_route(:put, *args, &block)
+    end
+
+    def post(*args, &block)
+      self.register_route(:post, *args, &block)
+    end
+
+    def delete(*args, &block)
+      self.register_route(:delete, *args, &block)
+    end
+    
+    # Returns a lambda that routes request to a controller/action.
+    #TODO move to RouteHelpers
+    def call(controller, action)
+      lambda {
+        controller = Object.const_get(controller)
+        action ||= Configuration::Base.app.default_action
+
+        instance = controller.new
+        request.controller  = instance
+        request.action      = action
+
+        instance.send(action)
+      }
+    end
+
+    # Creates a handler.
+    #
+    def handler(name, *args, &block)
+      code, fn = args
+
+      fn = code and code = nil if code.is_a?(Proc)
+      fn = block if block_given?
+
+      @handlers << [name, code, [fn]]
+    end
+
+    def group(name, *args, &block)
+      # deep clone existing hooks to reset at the close of this group
+      original_hooks = Marshal.load(Marshal.dump(@scope[:hooks]))
+      
+      @scope[:hooks] = self.merge_hooks(@scope[:hooks], args[0]) if @scope[:hooks] && args[0]
+
+      @scope[:name] = name
+      @groups[name] = []
+      @grouped_routes_by_name[name] = {}
+
+      self.instance_exec(&block)
+      @scope[:name] = nil
+      
+      @scope[:hooks] = original_hooks
+    end
+
+    def namespace(path, *args, &block)
+      name, hooks = args
+      hooks = name if name.is_a?(Hash)
+
+      original_path  = @scope[:path]
+      @scope[:path] = File.join(@scope[:path], path)
+      
+      self.group(name, hooks || {}, &block)
+      @scope[:path] = original_path
+    end
+
+    def template(name, &block)
+      @templates[name] = block
+    end
+
+    def expand(t_name, g_name, path = nil, data = nil, &block)
+      data = path and path = nil if path.is_a?(Hash)
+
+      # evaluate block in context of some class that implements
+      # method_missing to store map of functions 
+      # (e.g. index, show)
+      t = RouteTemplate.new(block, g_name, path, self)
+
+      # evaluate template in same context, where func looks up funcs
+      # from map and extends get (and others) to add proper names
+      t.expand(@templates[t_name], data)
+    end
+
+    # Returns a route tuple:
+    # [regex, vars, name, fns, path]
+    #
+    def match(path, method)
+      path = StringUtils.normalize_path(path)
+
+      @routes[method.to_sym].each{|r| 
+        case r[0]
+        when Regexp
+          if data = r[0].match(path)
+            return r, data
+          end
+        when String
+          if r[0] == path
+            return r, nil
+          end
+        end
+      }
+
+      nil
+    end
+
+    def handle(name_or_code)
+      @handlers.each{ |h|
+        return h if h[0] == name_or_code || h[1] == name_or_code
+      }
+
+      nil
+    end
+
+    # Name based route lookup
+    def route(name, group = nil)
+      return @routes_by_name[name] unless group
+
+      if grouped_routes = @grouped_routes_by_name[group]
+        grouped_routes[name]
+      end
+    end
+
+    protected
+
+    def merge_hooks(h1, h2)
+      # normalize
+      h1[:before]  ||= []
+      h1[:after]   ||= []
+      h1[:around]  ||= []
+      h2[:before]  ||= []
+      h2[:after]   ||= []
+      h2[:around]  ||= []
+
+      # merge
+      h1[:before].concat(h2[:before])
+      h1[:after].concat(h2[:after])
+      h1[:around].concat(h2[:around])
+      h1
+    end
+
+    def register_route(method, path, *args, &block)
+      name, fns, hooks = self.parse_route_args(args)
+
+      fns ||= []
+      # add passed block to fns
+      fns << block if block_given?
+      
+      hooks = self.merge_hooks(hooks || {}, @scope[:hooks])
+
+      # build the final list of fns
+      fns = self.build_fns(fns, hooks)
+
+      # prepend scope path if we're in a scope
+      path = File.join(@scope[:path], path)
+      path = StringUtils.normalize_path(path)
+      
+      # get regex and vars for path
+      regex, vars = self.build_route_matcher(path)
+
+      # create the route tuple
+      route = [regex, vars, name, fns, path]
+
+      @routes[method] << route
+      @routes_by_name[name] =  route
+
+      # store group references if we're in a scope
+      return unless group = @scope[:name]
+      @groups[group] << route
+      @grouped_routes_by_name[group][name] = route
+    end
+
+    def parse_route_args(args)
+      ret = []
+      args.each { |arg|
+        if arg.is_a?(Hash) # we have hooks
+          ret[2] = arg
+        elsif arg.is_a?(Array) # we have fns
+          ret[1] = arg
+        elsif arg.is_a?(Proc) # we have a fn
+          ret[1] = [arg]
+        elsif !arg.nil? # we have a name
+          ret[0] = arg
+        end
+      }
+      ret
+    end
+    
+    def build_fns(main_fns, hooks)
+      fns = []
+      fns.concat(hooks[:around])  if hooks && hooks[:around]
+      fns.concat(hooks[:before])  if hooks && hooks[:before]
+      fns.concat(main_fns)        if main_fns
+      fns.concat(hooks[:after])   if hooks && hooks[:after]
+      fns.concat(hooks[:around])  if hooks && hooks[:around]
+      fns
+    end
+
+    def build_route_matcher(path)
+      return path, [] if path.is_a?(Regexp)
+
+      # check for vars
+      return path, [] unless path[0,1] == ':' || path.index('/:')
+      
+      # we have vars
+      vars = []
+      position_counter = 1
+      regex_route = path
+      route_segments = path.split('/')
+      route_segments.each_with_index { |segment, i|
+        if segment.include?(':')
+          vars << { :position => position_counter, :var => segment.gsub(':', '').to_sym }
+          if i == route_segments.length-1 then
+            regex_route = regex_route.sub(segment, '((\w|[-.~:@!$\'\(\)\*\+,;])*)')
+            position_counter += 2
+          else
+            regex_route = regex_route.sub(segment, '((\w|[-.~:@!$\'\(\)\*\+,;])*)')
+            position_counter += 2
+          end
+        end
+      }
+      reg = Regexp.new("^#{regex_route}$")
+      return reg, vars
+    end
+  end
+end
+

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

@@ -0,0 +1,77 @@
+#TODO rename router to set and .func to .fn
+
+module Pakyow
+  class RouteTemplate
+    attr_accessor :path
+
+    def initialize(block, g_name, path, router)
+      @fns    = {}
+      @g_name = g_name
+      @path   = path
+      @router = router
+
+      self.instance_exec(&block)
+    end
+
+    def action(method, *args, &block)
+      fns = block_given? ? [block] : args[0]
+      @fns[method] = fns
+    end
+
+    def expand(template, data)
+      @expanding = true
+
+      t = self
+      if @path
+        @router.namespace(@path, @g_name) {
+          t.instance_exec(data, &template)
+        }
+      else
+        @router.group(@g_name) {
+          t.instance_exec(data, &template)
+        }
+      end
+    end
+
+    def fn(name)
+      @expanding ? @fns[name] : @router.func(name)
+    end
+
+    def call(controller, action)
+      @router.call(controller, action)
+    end
+
+    def get(*args, &block)
+      @router.get(*args, &block)
+    end
+
+    def put(*args, &block)
+      @router.put(*args, &block)
+    end
+
+    def post(*args, &block)
+      @router.post(*args, &block)
+    end
+
+    def delete(*args, &block)
+      @router.delete(*args, &block)
+    end
+
+    #TODO best name?
+    def map_actions(controller, actions)
+      actions.each { |a|
+        self.action(a, self.call(controller, a))
+      }
+    end
+
+    #TODO best name?
+    def map_restful_actions(controller)
+      self.map_actions(controller, self.restful_actions)
+    end
+
+    def restful_actions
+      [:index, :show, :new, :create, :edit, :update, :delete]
+    end
+  end
+end
+

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

@@ -0,0 +1,29 @@
+module Pakyow
+  class RouteTemplateDefaults
+    def self.register
+      Pakyow::Router.instance.set(:default) {
+        template(:restful) {
+          get '/', :index, fn(:index)
+
+          # special case for show (view path is overridden)
+          if show_fns = fn(:show)
+            show_fns = [show_fns] unless show_fns.is_a?(Array)
+            get '/:id', :show, show_fns.unshift(
+              lambda {
+                presenter.view_path = File.join(self.path, 'show') if Configuration::Base.app.presenter
+              }
+            )
+          end
+
+          get '/new', :new, fn(:new)
+          post '/', :create, fn(:create)
+
+          get '/:id/edit', :edit, fn(:edit)
+          put '/:id', :update, fn(:update)
+
+          delete '/:id', :delete, fn(:delete)
+        }
+      }
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+require 'singleton'
+
+module Pakyow
+  # A singleton that manages route sets.
+  #
+  class Router
+    include Singleton
+
+    def initialize
+    end
+
+    def reset
+      @sets = {}
+      RouteTemplateDefaults.register
+      self
+    end
+
+    # Creates a new set (or appends to a set if it exists).
+    #
+    def set(name, &block)
+      @sets[name] ||= RouteSet.new
+      @sets[name].instance_exec(&block)
+    end
+
+    # Iterates through route sets and returns the first matching route.
+    #
+    def route(name, group = nil)
+      @sets.each { |set|
+        if r = set[1].route(name, group)
+          return r
+        end
+      }
+
+      nil
+    end
+
+    # Performs the initial routing for a request.
+    #
+    def route!(request)
+      self.trampoline(self.match(request))
+    end
+
+    # Reroutes a request.
+    #
+    def reroute!(request)
+      throw :fns, self.match(request)
+    end
+
+    # Finds and invokes a handler by name or by status code.
+    #
+    def handle!(name_or_code, from_logic = false)
+      @sets.each { |set|
+        if h = set[1].handle(name_or_code)
+          Pakyow.app.response.status = h[0]
+          from_logic ? throw(:fns, h[2]) : self.trampoline(h[2])
+          break
+        end
+      }
+    end
+
+    def routed?
+      @routed
+    end
+
+    # Looks up and populates a path with data
+    #
+    def path(name, data = nil)
+      RouteLookup.new.path(name, data)
+    end
+
+    # Looks up a route grouping
+    #
+    def group(name)
+      RouteLookup.new.group(name)
+    end
+
+    protected
+
+    # Calls a list of route functions in order (each in a separate context).
+    #
+    def call_fns(fns)
+      fns.each {|fn| self.context.instance_exec(&fn)}
+    end
+
+    # Creates a context in which to evaluate a route function.
+    #
+    def context
+      FnContext.new
+    end
+
+    # Finds the first matching route for the request path/method and
+    # returns the list of route functions for that route.
+    #
+    def match(request)
+      path   = StringUtils.normalize_path(request.working_path)
+      method = request.working_method
+
+      @routed = false
+
+      match, data = nil
+      @sets.each { |set|
+        match, data = set[1].match(path, method)
+        break if match
+      }
+
+      fns = []
+      if match
+        fns = match[3]
+
+        # handle route params
+        #TODO where to do this?
+        request.params.merge!(HashUtils.strhash(self.data_from_path(path, data, match[1])))
+
+        #TODO where to do this?
+        request.route_path = match[4]
+      end
+
+      fns
+    end
+
+    # Calls route functions and catches new functions as
+    # they're thrown (e.g. by reroute).
+    #
+    def trampoline(fns)
+      until fns.empty?
+        fns = catch(:fns) {
+          self.call_fns(fns)
+
+          # Getting here means that call() returned normally (not via a throw)
+          :fall_through
+        } # end :fns catch block
+
+        # If reroute! or invoke_handler! was called in the block, block will have a new value (nil or block).
+        # If neither was called, block will be :fall_through
+
+        @routed = case fns
+          when []             then false
+          when :fall_through  then fns = [] and true
+        end
+      end
+    end
+
+    # Extracts the data from a path.
+    #
+    def data_from_path(path, matches, vars)
+      data = {}
+      return data unless matches
+
+      vars.each {|v|
+        data[v[:var]] = matches[v[:position]]
+      }
+
+      data
+    end
+  end
+end

data/pakyow-core/lib/generators/pakyow/app/app_generator.rb

@@ -5,7 +5,8 @@ module Pakyow
     class AppGenerator
       class << self
         def start
-          if ARGV.first == '--help' || ARGV.first == '-h'
+          case ARGV.first
+          when '--help', '-h', nil
             puts File.open(File.join(CORE_PATH, 'commands/USAGE-NEW')).read
           else
             generator = self.new
@@ -19,7 +20,16 @@ module Pakyow
       end
       
       def build(dest)
-        FileUtils.cp_r(@src, dest)
+        if !File.directory?(dest) || (Dir.entries(dest) - ['.', '..']).empty?
+          FileUtils.cp_r(@src, dest)
+        else
+          ARGV.clear
+          print "The folder '#{dest}' is in use. Would you like to populate it anyway? [Yn] "
+
+          if gets.chomp! == 'Y'
+            FileUtils.cp_r(@src, dest)
+          end
+        end
       end
     end
   end

data/pakyow-core/lib/generators/pakyow/app/templates/app.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'pakyow'
+
+module PakyowApplication
+  class Application < Pakyow::Application
+    core do
+      default {
+        puts 'Pakyow says hello!'
+      }
+    end
+  end
+end

data/pakyow-core/lib/generators/pakyow/app/templates/config.ru

@@ -1,3 +1,3 @@
-require File.expand_path('../config/application', __FILE__)
+require File.expand_path('app', __FILE__)
 PakyowApplication::Application.builder.run(PakyowApplication::Application.stage(ENV['RACK_ENV']))
 run PakyowApplication::Application.builder.to_app

data/pakyow-core/lib/generators/pakyow/app/templates/rakefile

@@ -1,2 +1,2 @@
-require File.expand_path('../config/application', __FILE__)
+require File.expand_path('application', __FILE__)
 PakyowApplication::Application.stage(ENV['ENV'])

data/pakyow-core/lib/generators/pakyow/app/templates/{app/views → views}/pakyow.html

@@ -6,7 +6,7 @@
 
 <body>
   <div id="wrapper">
-    <div id="main"></div>
+    <div data-container="main"></div>
   </div>
 </body>
 </html>

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

@@ -3,16 +3,6 @@ module Pakyow
   # Utility methods for strings.
   class StringUtils
 
-    # Creates an underscored, lowercase version of a string.
-    # This was borrowed from another library, probably ActiveSupport.
-    def self.underscore(string)
-      string.gsub(/::/, '/').
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').
-        tr("-", "_").
-        downcase
-    end
-
     # split . seperated string at the last .
     def self.split_at_last_dot(s)
       split_index = s.rindex('.')
@@ -32,6 +22,17 @@ module Pakyow
       return ret
     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)
+
+      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
 end