pakyow-core 0.11.3 → 1.0.0.rc1

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

@@ -1,119 +0,0 @@
-require 'json'
-require 'rack'
-
-module Pakyow
-
-  # The Request object.
-  class Request < Rack::Request
-    attr_accessor :restful, :route_path, :controller, :action, :format,
-    :error, :path, :method, :paths, :methods, :formats
-
-    def initialize(*args)
-      super
-
-      @paths = []
-      @methods = []
-      @formats = []
-
-      @path = path_info
-      @method = request_method.downcase.to_sym
-
-      setup
-    end
-
-    def path=(path)
-      @paths << path
-      @path = path
-    end
-
-    def method=(method)
-      @methods << method
-      @method = method
-    end
-
-    def format=(format)
-      format = format ? format.to_sym : :html
-      @formats << format
-      @format = format
-    end
-
-    def first_path
-      @paths[0]
-    end
-
-    def first_method
-      @methods[0]
-    end
-
-    def first_format
-      @formats[0]
-    end
-
-    def session
-      self.env['rack.session'] || {}
-    end
-
-    def cookies
-      @cookies ||= Hash.strhash(super)
-    end
-
-    # Returns indifferent params (see {HashUtils.strhash} for more info on indifferent hashes).
-    def params
-      return @params unless @params.nil?
-
-      @params = super
-      @params.merge!(env['pakyow.data']) if env['pakyow.data'].is_a?(Hash)
-      @params.merge!(JSON.parse(body.read.to_s)) if format == :json
-      @params = Hash.strhash(@params)
-    end
-
-    # Returns array of url components.
-    def path_parts
-      @url ||= path ? self.class.split_url(path) : []
-    end
-
-    def referer
-      @referer ||= env['HTTP_REFERER']
-    end
-
-    # Returns array of referer components.
-    def referer_parts
-      @referer_parts ||= referer ? self.class.split_url(referer) : []
-    end
-
-    def setup(path = self.path, method = nil)
-      set_request_format_from_path(path)
-      set_working_path_from_path(path, method)
-    end
-
-    #TODO move to util class
-    def self.split_url(url)
-      arr = []
-      url.split('/').each { |r|
-        arr << r unless r.empty?
-      }
-
-      return arr
-    end
-
-    def has_route_vars?
-      return false if @route_path.nil?
-      return false if @route_path.is_a?(Regexp)
-      return true  if @route_path.index(':')
-    end
-
-    protected
-
-    def set_working_path_from_path(path, method)
-      base_route, ignore_format = String.split_at_last_dot(path)
-
-      self.path = base_route
-      self.method = method || self.method
-    end
-
-    def set_request_format_from_path(path)
-      path, format = String.split_at_last_dot(path)
-      self.format = ((format && (format[format.length - 1, 1] == '/')) ? format[0, format.length - 1] : format)
-    end
-  end
-end

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

@@ -1,135 +0,0 @@
-module Pakyow
-
-  # The Response object.
-  class Response < Rack::Response
-    attr_reader :format
-
-    DEFAULT_CONTENT_TYPE = 'text/html;charset=utf-8'.freeze
-
-    STATUS_CODE_NAMES = {
-      100 => 'Continue',
-      101 => 'Switching Protocols',
-
-      200 => 'OK',
-      201 => 'Created',
-      202 => 'Accepted',
-      203 => 'Non-Authoritative Information',
-      204 => 'No Content',
-      205 => 'Reset Content',
-      206 => 'Partial Content',
-
-      300 => 'Multiple Choices',
-      301 => 'Moved Permanently',
-      302 => 'Found',
-      303 => 'See Other',
-      304 => 'Not Modified',
-      305 => 'Use Proxy',
-      306 => 'Switch Proxy',
-      307 => 'Temporary Redirect',
-
-      400 => 'Bad Request',
-      401 => 'Unauthorized',
-      402 => 'Payment Required',
-      403 => 'Forbidden',
-      404 => 'Not Found',
-      405 => 'Method Not Allowed',
-      406 => 'Not Acceptable',
-      407 => 'Proxy Authentication Required',
-      408 => 'Request Timeout',
-      409 => 'Conflict',
-      410 => 'Gone',
-      411 => 'Length Required',
-      412 => 'Precondition Failed',
-      413 => 'Request Entity Too Large',
-      414 => 'Request-URI Too Long',
-      415 => 'Unsupported Media Type',
-      416 => 'Requested Range Not Satisfiable',
-      417 => 'Expectation Failed',
-      418 => 'I\'m a teapot',
-
-      500 => 'Internal Server Error',
-      501 => 'Not Implemented',
-      502 => 'Bad Gateway',
-      503 => 'Service Unavailable',
-      504 => 'Gateway Timeout',
-      505 => 'HTTP Version Not Supported',
-      506 => 'Variant Also Negotiates',
-      507 => 'Insufficient Storage',
-      508 => 'Loop Detected',
-      509 => 'Bandwidth Limit Exceeded',
-      510 => 'Not Extended',
-      511 => 'Network Authentication Required'
-    }
-
-    STATUS_CODE_LOOKUP = {
-      continue: 100,
-      switching_protocols: 101,
-
-      ok: 200,
-      created: 201,
-      accepted: 202,
-      non_authoritative_information: 203,
-      no_content: 204,
-      reset_content: 205,
-      partial_content: 206,
-
-      multiple_choices: 300,
-      moved_permanently: 301,
-      found: 302,
-      see_other: 303,
-      not_modified: 304,
-      use_proxy: 305,
-      reserved: 306,
-      temporary_redirect: 307,
-
-      bad_request: 400,
-      unauthorized: 401,
-      payment_required: 402,
-      forbidden: 403,
-      not_found: 404,
-      method_not_allowed: 405,
-      not_acceptable: 406,
-      proxy_authentication_required: 407,
-      request_timeout: 408,
-      conflict: 409,
-      gone: 410,
-      length_required: 411,
-      precondition_failed: 412,
-      request_entity_too_large: 413,
-      request_uri_too_long: 414,
-      unsupported_media_type: 415,
-      requested_range_not_satisfiable: 416,
-      expectation_failed: 417,
-      teapot: 418,
-
-      internal_server_error: 500,
-      not_implemented: 501,
-      bad_gateway: 502,
-      service_unavailable: 503,
-      gateway_timeout: 504,
-      http_version_not_supported: 505,
-      variant_also_negotiates: 506,
-      insufficient_storage: 507,
-      loop_detected: 508,
-      bandwidth_exceeded: 509,
-      not_extended: 510,
-      network_authentication_required: 511
-    }
-
-    def initialize(*args)
-      super
-
-      self["Content-Type"] ||= DEFAULT_CONTENT_TYPE
-      @format = Rack::Mime::MIME_TYPES.key(type)
-    end
-
-    def format=(format)
-      @format = format
-      self["Content-Type"] = format == :html ? DEFAULT_CONTENT_TYPE : Rack::Mime.mime_type(".#{format}")
-    end
-
-    def type
-      self["Content-Type"]
-    end
-  end
-end

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

@@ -1,254 +0,0 @@
-module Pakyow
-  class RouteEval
-    include RouteMerger
-
-    attr_reader :path, :fns, :hooks, :group, :routes, :handlers, :lookup, :templates
-
-    HTTP_METHODS   = [:get, :post, :put, :patch, :delete]
-    DEFAULT_MIXINS = ['Restful']
-
-    class << self
-      def with_defaults(*args)
-        instance = self.new(*args)
-
-        # Mixin defaults
-        DEFAULT_MIXINS.each { |mixin| instance.include(Pakyow::Routes.const_get(mixin)) }
-
-        return instance
-      end
-
-      def from_scope(route_eval, args = {})
-				[:path, :fns, :hooks, :templates, :group].each do |arg|
-          next unless value = route_eval.instance_variable_get(:"@#{arg}")
-          args[arg] ||= value.dup
-				end
-
-        self.new(args)
-      end
-    end
-
-    def initialize(path: '/', fns: {}, hooks: { before: [], after: [] }, templates: {}, group: nil)
-      @path      = path
-      @fns       = fns
-      @hooks     = hooks
-      @templates = templates
-      @group     = group
-
-      @routes    = HTTP_METHODS.inject({}) { |acc, m| acc[m] = []; acc }
-      @lookup    = { routes: {}, grouped: {} }
-      @handlers  = []
-    end
-
-    # Path for evals within this eval
-    #
-    def descendent_path
-      @descendent_path || @path
-    end
-
-    def include(route_module)
-      merge(route_module.route_eval)
-    end
-
-    def eval(&block)
-      instance_exec(&block)
-    end
-
-    # Creates or retreives a named route function.
-    #
-    def fn(name, &block)
-      if block_given?
-        @fns[name] = block
-      else
-        @fns[name]
-      end
-    end
-
-    # Creates a handler.
-    #
-    def handler(*args, &block)
-      args = Aargv.normalize(args, name: Symbol, code: Integer, fn: Proc, hooks: Hash)
-
-      fns = []
-      # add the passed proc
-      fns << args[:fn] unless args[:fn].nil?
-      # add passed block to fns
-      fns << block if block_given?
-
-      # build the final list of fns
-      fns = build_fns(fns, args[:hooks])
-
-      @handlers.unshift([args[:name], args[:code], fns])
-    end
-
-    def group(*args, &block)
-      name, hooks = self.class.parse_group_args(args)
-
-      evaluator = RouteEval.from_scope(self, path: descendent_path, group: name, hooks: hooks)
-      evaluator.eval(&block)
-
-      merge(evaluator)
-    end
-
-    def namespace(*args, &block)
-      path, name, hooks = self.class.parse_namespace_args(args)
-
-      evaluator = RouteEval.from_scope(self, path: File.join(descendent_path, path), group: name, hooks: hooks)
-      evaluator.eval(&block)
-
-      merge(evaluator)
-    end
-
-    def template(*args, &block)
-      args = Aargv.normalize(args, name: Symbol, hooks: Hash)
-      @templates[args[:name]] = [args[:hooks], block]
-    end
-
-    def expand(t_name, g_name = nil, *args, &block)
-      args = Aargv.normalize(args, path: [String, ''], hooks: Hash)
-      path = args[:path]
-      hooks = args[:hooks]
-      template = @templates[t_name]
-
-      evaluator = RouteExpansionEval.from_scope(self, path: File.join(descendent_path, path), group: g_name, hooks: hooks)
-			evaluator.direct_path = path
-      evaluator.set_template(g_name, template)
-      evaluator.eval(&block)
-
-      merge(evaluator)
-    end
-
-    def default(*args, &block)
-      build_route(:get, '/', :default, *args, &block)
-    end
-
-    HTTP_METHODS.each do |method|
-      define_method method do |*args, &block|
-        build_route(method, *args, &block)
-      end
-    end
-
-    # For the expansion of templates
-    def method_missing(method, *args, &block)
-      if template_defined?(method)
-        expand(method, *args, &block)
-      else
-        super
-      end
-    end
-
-    def template_defined?(template)
-      !@templates[template].nil?
-    end
-
-    protected
-
-		def build_route(method, *args, &block)
-      args = Aargv.normalize(args, path: String, regex_path: Regexp, name: Symbol, fn: Proc, fns: Array, hooks: Hash)
-
-      path = args[:path] || args[:regex_path]
-      name = args[:name]
-
-      fns = args[:fns] || []
-      # add passed fn
-      fns << args[:fn] unless args[:fn].nil?
-      # add passed block to fns
-      fns << block if block_given?
-
-      # merge route hooks with scoped hooks
-      hooks = merge_hooks(@hooks.dup, args[:hooks] || {})
-
-      # build the final list of fns
-      fns = build_fns(fns, hooks)
-
-      if path.is_a?(Regexp)
-        regex = path
-        vars  = []
-      else
-        # prepend scope path if we're in a scope
-        path = File.join(@path, path)
-        path = String.normalize_path(path)
-
-        # get regex and vars for path
-        regex, vars = build_route_matcher(path)
-      end
-
-			register_route([regex, vars, name, fns, path, method])
-		end
-
-    def register_route(route)
-      @routes[route[5]] << route
-
-      if group?
-        bucket = (@lookup[:grouped][@group] ||= {})
-      else
-        bucket = @lookup[:routes]
-      end
-
-			bucket[route[2]] = route
-    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 = []
-      regex_route = path
-      route_segments = path.split('/')
-      route_segments.each_with_index { |segment, i|
-        if segment.include?(':')
-          var = segment.gsub(':', '')
-          vars << { :var => var.to_sym, :url_position => i }
-          regex_route = regex_route.sub(segment, '(?<' + var + '>(\w|[-.~:@!$\'\(\)\*\+,;])*)')
-        end
-      }
-      reg = Regexp.new("^#{regex_route}$")
-      return reg, vars
-    end
-
-    def group?
-      !@group.nil?
-    end
-
-    def build_fns(main_fns, hooks)
-      hooks = normalize_hooks(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
-
-    class << self
-      def parse_namespace_args(args)
-        ret = []
-        args.each { |arg|
-          if arg.is_a?(Hash) # we have hooks
-            ret[2] = arg
-          elsif arg.is_a?(Symbol) # we have a name
-            ret[1] = arg
-          elsif !arg.nil? # we have a path
-            ret[0] = arg
-          end
-        }
-        ret
-      end
-
-      def parse_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
-end

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

@@ -1,115 +0,0 @@
-module Pakyow
-  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
-      
-      instance_exec(&@template_eval.post_process) if @template_eval.post_process
-    end
-
-    def set_template(expansion_name, template)
-      @expansion_name = expansion_name
-      @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(all_fns[:hooks], 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(@expansion_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(@expansion_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|
-          if arg.is_a?(Hash) # we have hooks
-            ret[1] = arg
-          elsif arg.is_a?(Proc) # we have a fn
-            ret[0] = arg
-          end
-        }
-        ret
-      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
-end

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

@@ -1,41 +0,0 @@
-module Pakyow
-
-  # Handles looking up paths for named routes and populating
-  # the path with data.
-  #
-  class RouteLookup
-    include Helpers
-
-    def path(name, data = nil)
-      route = get_named_route(name)
-      data ? populate(route, data) : File.join('/', route[4])
-    end
-
-    def group(name)
-      @group = name
-      self
-    end
-
-    protected
-
-    def get_named_route(name)
-      if defined? @group
-        Router.instance.route(name, @group)
-      else
-        Router.instance.route(name)
-      end
-    end
-
-    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])
-      }
-
-      File.join('/', split_path.join('/'))
-    end
-  end
-end