pakyow-core 0.11.3 → 1.0.0.rc1

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

@@ -1,76 +0,0 @@
-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].deep_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/pakyow/core/route_module.rb

@@ -1,21 +0,0 @@
-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/pakyow/core/route_set.rb

@@ -1,74 +0,0 @@
-module Pakyow
-  class RouteSet
-    include RouteMerger
-
-    attr_reader :routes, :lookup
-
-    def initialize
-      @routes = {:get => [], :post => [], :put => [], :patch => [], :delete => []}
-      @lookup = { :routes => {}, :grouped => {}}
-      @handlers = []
-      @fns = {}
-      @templates = {}
-    end
-
-    def eval(&block)
-      evaluator = RouteEval.with_defaults
-      evaluator.eval(&block)
-      merge(evaluator)
-    end
-
-    # Returns a route tuple:
-    # [regex, vars, name, fns, path]
-    #
-    def match(path, method)
-      path = String.normalize_path(path)
-
-      # 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 do |r|
-        #TODO can we do this without conditionals? fall-through?
-        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
-      end
-
-      nil
-    end
-
-    def handle(name_or_code)
-      @handlers.each{ |h|
-        return h if h[0] == name_or_code || h[1] == name_or_code
-      }
-
-      #TODO raise error
-      nil
-    end
-
-    # Name based route lookup
-    def route(name, group = nil)
-      return @lookup[:routes][name] if group.nil?
-
-      if grouped_routes = @lookup[:grouped][group]
-        return grouped_routes[name]
-      else
-        #TODO error (perhaps a set-specific exception rescued by router)
-      end
-    end
-
-    # Name based fn lookup
-    def fn(name)
-      return @fns[name]
-    end
-  end
-end
-

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

@@ -1,43 +0,0 @@
-module Pakyow
-  module Routes
-    module Restful
-      include Pakyow::Routes
-
-      template :restful do
-        resource_id = ":#{@group}_id"
-
-        nested_path { |path| File.join(path, resource_id) }
-        view_path = nested_path.gsub(/:[^\/]+/, '').split('/').reject { |p| p.empty? }.join('/')
-
-        fn :reset_view_path do
-          begin
-            presenter.path = File.join(view_path, 'show') if @presenter
-          rescue Presenter::MissingView
-          end
-        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 :remove, "/#{resource_id}"
-
-        group :collection
-        namespace :member, resource_id
-
-        post_process do
-          # the show route is weird; move it to the end of get routes to avoid conflicts
-          if show_index = @routes[:get].find_index { |route| route[2] == :show }
-            @routes[:get] << @routes[:get].delete_at(show_index)
-          end
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-module Pakyow
-  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
-    
-    def post_process(&block)
-      return @post_process unless block_given?
-      @post_process = block
-    end
-  end
-end

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

@@ -1,181 +0,0 @@
-require 'singleton'
-
-module Pakyow
-  # A singleton that manages route sets.
-  #
-  class Router
-    include Singleton
-
-    attr_reader :sets
-
-    def initialize
-      @sets = {}
-    end
-
-    #TODO want to do this for all sets?
-    def reset
-      @sets = {}
-      self
-    end
-
-    # Creates a new set.
-    #
-    def set(name, &block)
-      @sets[name] = RouteSet.new
-      @sets[name].eval(&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
-      }
-
-      raise MissingRoute, "Could not find route '#{name}'"
-    end
-
-    def exists?(context)
-      !match(context.request).empty?
-    end
-
-    # Performs the initial routing for a request.
-    #
-    def perform(context, app = Pakyow.app, &after_match)
-      fns = match(context.request)
-      after_match.call if block_given?
-
-      trampoline(fns, app)
-    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, app = Pakyow.app, from_logic = false)
-      app.response.status = name_or_code if name_or_code.is_a?(Integer)
-
-      @sets.each { |set|
-        if h = set[1].handle(name_or_code)
-          app.response.status = h[1]
-          from_logic ? throw(:fns, h[2]) : self.trampoline(h[2], app)
-          break
-        end
-      }
-    end
-
-    # Looks up and populates a path with data
-    #
-    def path(name_or_path, data = nil)
-      if name_or_path.is_a?(String)
-        return name_or_path
-      elsif name_or_path.is_a?(Hash)
-        RouteLookup.new.group(name_or_path.keys[0]).path(name_or_path.values[0], data)
-      else
-        RouteLookup.new.path(name_or_path, data)
-      end
-    end
-
-    # Looks up a route grouping
-    #
-    def group(name)
-      RouteLookup.new.group(name)
-    end
-
-    # Calls a defined fn
-    #
-    def fn(name, app = nil)
-      @sets.each { |set|
-        if fn = set[1].fn(name)
-          if app.nil?
-            fn.call
-          else
-            app.instance_exec(&fn)
-          end
-
-          break
-        end
-      }
-    end
-
-    protected
-
-    # Calls a list of route functions in order (in a shared context).
-    #
-    def call_fns(fns, app)
-      fns.each {|fn| app.instance_exec(&fn)}
-    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   = String.normalize_path(request.path)
-      method = request.method
-
-      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!(Hash.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, app)
-      routed = false
-      until fns.empty?
-        fns = catch(:fns) {
-          self.call_fns(fns, app)
-
-          # 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
-
-      return routed
-    end
-
-    # Extracts the data from a path.
-    #
-    def data_from_path(path, matches, vars)
-      data = {}
-      return data unless matches
-
-      matches.names.each {|var|
-        data[var.to_sym] = matches[var]
-      }
-
-      data
-    end
-  end
-end

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

@@ -1,8 +0,0 @@
-require 'find'
-require 'rack'
-require 'rack/file'
-require 'logger'
-require 'cgi'
-
-require 'pakyow/support'
-require 'pakyow/core/base'

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

@@ -1 +0,0 @@
-require 'pakyow/core'