orange-core 0.5.3

data/lib/orange-core/middleware/show_exceptions.rb

@@ -0,0 +1,80 @@
+require 'ostruct'
+require 'rack/request'
+require 'rack/utils'
+require 'orange-core/middleware/base'
+
+module Orange::Middleware
+  # Rack::ShowExceptions catches all exceptions raised from the app it
+  # wraps.  It shows a useful backtrace with the sourcefile and
+  # clickable context, the whole Rack environment and the request
+  # data.
+  #
+  # Be careful when you use this on public-facing sites as it could
+  # reveal information helpful to attackers.
+  #
+  # Orange::Middleware::ShowExceptions is a slightly modified
+  # version of Rack::ShowExceptions
+  class ShowExceptions < Base
+    CONTEXT = 7
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => e
+      backtrace = pretty(env, e)
+      
+      [500,
+       {"Content-Type" => "text/html",
+        "Content-Length" => backtrace.join.size.to_s},
+       backtrace]
+    end
+    
+    def packet_call(packet)
+      backtrace = pretty()
+    end
+
+    def pretty(env, exception)
+      req = Rack::Request.new(env)
+      path = (req.script_name + req.path_info).squeeze("/")
+
+      frames = exception.backtrace.map { |line|
+        frame = OpenStruct.new
+        if line =~ /(.*?):(\d+)(:in `(.*)')?/
+          frame.filename = $1
+          frame.lineno = $2.to_i
+          frame.function = $4
+
+          begin
+            lineno = frame.lineno-1
+            lines = ::File.readlines(frame.filename)
+            frame.pre_context_lineno = [lineno-CONTEXT, 0].max
+            frame.pre_context = lines[frame.pre_context_lineno...lineno]
+            frame.context_line = lines[lineno].chomp
+            frame.post_context_lineno = [lineno+CONTEXT, lines.size].min
+            frame.post_context = lines[lineno+1..frame.post_context_lineno]
+          rescue
+          end
+
+          frame
+        else
+          nil
+        end
+      }.compact
+
+      env["rack.errors"].puts "#{exception.class}: #{exception.message}"
+      env["rack.errors"].puts exception.backtrace.map { |l| "\t" + l }
+      env["rack.errors"].flush
+      orange_env = env["orange.env"]
+      parse = orange[:parser].haml("exceptions.haml", binding, :template => true)
+      [parse]
+    end
+
+    def h(obj)                  # :nodoc:
+      case obj
+      when String
+        Rack::Utils.escape_html(obj)
+      else
+        Rack::Utils.escape_html(obj.inspect)
+      end
+    end
+  end
+end

data/lib/orange-core/middleware/static.rb

@@ -0,0 +1,67 @@
+require 'orange-core/middleware/base'
+require 'orange-core/middleware/static_file'
+
+module Orange::Middleware
+  # The Orange::Middleware::Static middleware intercepts requests for static files
+  # (javascript files, images, stylesheets, etc) based on the url prefixes
+  # passed in the options, and serves them using a Rack::File object. 
+  #
+  # This differs from Rack::Static in that it can serve from multiple roots
+  # to accommodate both Orange static files and site specific ones.
+  # urls and root act the same as they do for Rack::Static. Only :libs option acts
+  # specially.
+  # 
+  # Each lib is responsible for responding to static_url and static_dir
+  # 
+  # Examples:
+  #           use Orange::Middleware::Static  :libs => [Orange::Core, AwesomeMod]
+  #           use Orange::Middleware::Static  :libs => [Orange::Core, AwesomeMod],
+  #                                           :urls => ["/favicon.ico"]
+  #
+  #         => Example 1 would load a file root for Orange::Core and Awesome Mod
+  #             Orange::Core static_url is _orange_, and dir is the
+  #             orange lib/assets folder
+  #         => Example 2 would also redirect favicon.ico to the assets dir
+  #
+  # 
+  # Note that as a general rule, Orange will assume everything static to be in an
+  # /assets/ subfolder, therefore, '/assets' will be prepended to the url given
+  # by static_url
+  # Also note, that since this is the case - setting up a match for general '/assets'
+  # could yield unpredictable results
+  #
+  # a static_url corresponds to the :module => in the add_css and add_js helpers
+  class Static < Base
+
+    def initialize(app, core, options={})
+      @lib_urls = {'_orange_' => File.join(core.core_dir, 'assets') }
+      Orange.plugins.each{|p| @lib_urls[p.assets_name] = p.assets if p.has_assets?}
+      
+      @app = app
+      @core = core      
+      @urls = options[:urls] || ["/favicon.ico", "/assets/public", "/assets/uploaded"]
+      @root = options[:root] || File.join(orange.app_dir, 'assets')
+      @file_server = Orange::Middleware::StaticFile.new(@root)
+    end
+
+    def packet_call(packet)
+      path = packet.env["PATH_INFO"]
+      can_serve_lib = @lib_urls.select { |url, server| 
+        path.index(File.join('', 'assets', url)) == 0 
+      }.first
+      can_serve = @urls.any?{|url| path.index(url) == 0 }
+      if can_serve_lib
+        lib_url = can_serve_lib.first
+        packet['file.root'] = can_serve_lib.last
+        packet['route.path'] = path.split(lib_url, 2).last        
+        @file_server.call(packet.env)
+      elsif can_serve
+        packet['route.path'] = path.gsub(/^\/assets/, '')
+        @file_server.call(packet.env)
+      else
+        pass packet
+      end
+    end
+
+  end
+end

data/lib/orange-core/middleware/static_file.rb

@@ -0,0 +1,32 @@
+require 'rack'
+require 'rack/utils'
+
+module Orange::Middleware
+  # Rack::File serves files below the +root+ given, according to the
+  # path info of the Rack request.
+  # Orange::Middleware::StaticFile acts the same as Rack::File, but acts on
+  # the orange specific path if available. (So site url would be ignored, etc.)
+  #
+  # Handlers can detect if bodies are a Rack::File, and use mechanisms
+  # like sendfile on the +path+.
+
+  class StaticFile < Rack::File
+    def _call(env)
+      @path_info = Rack::Utils.unescape(env['orange.env']["route.path"]) || Rack::Utils.unescape(env["PATH_INFO"])
+      @root = env['orange.env']['file.root'] || @root
+      return forbidden  if @path_info.include? ".."
+
+      @path = F.join(@root, @path_info)
+
+      begin
+        if F.file?(@path) && F.readable?(@path)
+          serving
+        else
+          raise Errno::EPERM
+        end
+      rescue SystemCallError
+        not_found
+      end
+    end
+  end
+end

data/lib/orange-core/middleware/template.rb

@@ -0,0 +1,60 @@
+require 'orange-core/core'
+require 'orange-core/middleware/base'
+
+module Orange::Middleware
+  
+  class Template < Base
+    def init(*args)
+      @core.add_pulp(Orange::Pulp::Template)
+      @core.mixin(Orange::Mixins::Template)
+      
+    end
+    
+    def packet_call(packet)
+      packet['template.file'] = orange.template_for packet
+      status, headers, content = pass packet
+      if needs_wrapped?(packet)
+        content = wrap(packet, content)
+        packet[:content] = content.first
+        orange.fire(:wrapped, packet)
+      end  
+      orange.fire(:after_wrap, packet)
+      packet.finish
+    end
+    
+    def needs_wrapped?(packet)
+      return false if packet.request.xhr? && !packet['template.enable'] # don't wrap xhr unless specifically asked to
+      packet['template.file'] && !packet['template.disable'] 
+    end
+    
+    def wrap(packet, content = false)
+      content = packet.content unless content
+      content = content.join
+      content = orange[:parser].haml(packet['template.file'], packet, :wrapped_content => content, :template => true) do 
+        content
+      end
+      [content]
+    end
+  end
+end
+
+module Orange::Pulp::Template
+  def wrap
+    packet[:content] = orange[:parser].haml(packet['template.file'], packet, :wrapped_content => packet[:content], :template => true) do
+      content
+    end
+  end
+end
+
+module Orange::Mixins::Template
+  def template_for(packet)
+    template_chooser.call(packet)
+  end
+  def template_chooser(&block)
+    if block_given?
+      @template_chooser = Proc.new
+    else
+      @template_chooser ||= Proc.new {|packet| false}
+    end
+  end
+end

data/lib/orange-core/packet.rb

@@ -0,0 +1,232 @@
+module Orange
+  # Orange::Packet is a wrapper for Rack's basic env variable. 
+  # It acts somewhat like Rack::Request, except with more functionality.
+  # For each request a unique Packet is generated, and this packet is 
+  # used to by middleware to create the response. 
+  # 
+  # All orange enhanced middleware has a packet_call method that
+  # automatically turns the generic rack call(env) into a call
+  # that has a packet instead, so all functions for the packet should
+  # be available for the request.
+  #
+  # Pulps are modules that are mixed into the Packet, allowing
+  # additional functionality to be used by the packet.
+  #
+  # By default, haml files are parsed in the context of their
+  # packet. This means all of instance variables and functions should
+  # be available to the haml parser.
+  class Packet
+    # By default, header will be content-type
+    DEFAULT_HEADERS = {"Content-Type" => 'text/html'} unless defined?(DEFAULT_HEADERS)
+    
+    # We override the instantiation to only create one packet per env
+    # @param [Orange::Core] orange a pointer to the orange core
+    # @param [Hash] env a standard Rack hash
+    def self.new(orange, env)
+      return env['orange.packet'] if env['orange.packet']
+      super(orange, env)
+    end
+    
+    # Allows tying in to the method_missing method without redefining it 
+    # elsewhere. This lets dynamic methods be defined on the packet.
+    # Regexes are defined to match method names. #method_missing will
+    # loop through and try to find a match, executing the proc defined in
+    # the block.
+    # @param [Regexp] regex the regex to match
+    # @yield [Orange::Packet, MatchData, args] the block to execute if matched 
+    #   (passed instance, match data and args)
+    def self.meta_methods(regex, &block)
+      return unless block_given?
+      proc = block
+      @@matchers ||= {}
+      @@matchers[regex] = proc
+    end
+    
+    # Allows access to the matchers added via the #meta_methods method
+    # @return [Hash] the matchers hash
+    def matchers
+      @@matchers || {}
+    end
+    
+    # Initialize is only called if a packet hasn't already been called for 
+    # this env. Sets up the basic env, creating a pointer back to self
+    # and a Rack::Request object.
+    # @param [Orange::Core] orange a pointer to the orange core
+    # @param [Hash] env a standard Rack hash
+    def initialize(orange, env)
+      @orange = orange
+      @env = env
+      @env['orange.packet'] = self
+      @env['orange.env'] = {} unless @env['orange.env']
+      @env['orange.env'][:request] = Rack::Request.new(env)
+      @env['orange.env'][:headers] = {}
+    end
+    
+    # Gives access to the orange.env key in the env, optionally 
+    # including a default if key isn't involved.
+    # @param [Symbol, String] key the key to be found
+    # @param [optional, Object] default the return value if key doesn't exist (default is false)
+    # @return [Object] any value stored in the env
+    def [](key, default = false)
+      @env['orange.env'].has_key?(key) ? @env['orange.env'][key] : default
+    end
+    
+    # Lets user set a value in the orange.env
+    # @param [Symbol, String] key the key to be set
+    # @param [Object] val the value to be set
+    def []=(key, val)
+      @env['orange.env'][key] = val
+    end
+    
+    # Access to the main env (orange env is stored within the main env)
+    # @return [Hash] the request's env hash
+    def env
+      @env
+    end
+    
+    # Access to the rack session
+    # @return [Hash] the session information made available by Rack
+    def session
+      env['rack.session']["flash"] ||= {}
+      env['rack.session']
+    end
+    
+    # Access to the rack session flash
+    # @return [String] the string stored in the flash
+    def flash(key = nil, val = nil)
+      env['rack.session']["flash"] ||= {}
+      if key.nil? && val.nil?
+        env['rack.session']["flash"]
+      elsif val.nil?
+        env['rack.session']["flash"].delete(key)
+      else
+        env['rack.session']["flash"][key] = val
+      end
+    end 
+    
+    # Generate headers for finalization
+    # @return [Hash] the header information stored in the orange.env, combined with the defaults
+    #   set as DEFAULT_HEADERS
+    def headers
+      packet[:headers, {}].with_defaults(DEFAULT_HEADERS)
+    end
+    
+    # Set a header
+    # @param [String] key the key to be set
+    # @param [Object] val the value to be set
+    def header(key, val)
+      @env['orange.env'][:headers][key] = val
+    end
+    
+    # Set a header (same as #header)
+    # @param [String] key the key to be set
+    # @param [Object] val the value to be set
+    def add_header(key, val)
+      header key, val
+    end
+    
+    # Returns the content ready to be used by Rack (wrapped in an array)
+    # @return [Array] array of strings to be rendered
+    def content
+      # Stringify content if it isn't a string for some weird reason.
+      packet[:content] = packet[:content].to_s unless packet[:content].is_a? String
+      return [packet[:content]] if packet[:content]
+      return ['']
+    end
+    
+    # Returns the request object generated by Rack::Request(packet.env)
+    # @return [Rack::Request] the request object
+    def request
+      packet[:request]
+    end
+    
+    # A pointer to the Orange::Core instance
+    # @return [Orange::Core] the orange core run by the application
+    def orange
+      @orange
+    end
+    
+    # Returns the array of [status, headers, content] Rack expects
+    # @return [Array] the triple array expected by Rack at the end 
+    #   of a call
+    def finish
+      headers = packet.headers
+      status = packet[:status, 200]
+      content = packet.content
+      if content.respond_to?(:to_ary)
+        headers["Content-Length"] = content.to_ary.
+          inject(0) { |len, part| len + Rack::Utils.bytesize(part) }.to_s
+      end
+      [status, headers, content]
+    end
+    
+    # Returns self
+    # @return [Orange::Packet] self
+    def packet
+      self
+    end
+    
+    # Includes the module passed
+    # @param [Module] inc the module to be mixed into the class
+    def self.mixin(inc)
+      include inc
+    end
+    
+    # Route calls the router object set in the packet
+    # @return [void] route doesn't return anything directly, the
+    #   main application calls packet.route then returns packet.finish.
+    #   Routers set content, headers and status if necessary.
+    #   They can also raise redirect errors to circumvent the process.
+    def route
+      router = packet['route.router']
+      raise 'Router not found' unless router
+      router.route(self)
+    end
+    
+    # Pulls options set out of the packet and places them into
+    # a hash. Options are retrieved from POST, GET, and route.resource_path
+    # and take that order of precedence (POST overrides GET, etc)
+    # @param [Array] key_list an array of keys to retrieve and merge together
+    #   in order of precedence. :GET and :POST for request vars, the rest
+    #   are keys directly available on packet
+    # @return [Hash] A hash of options set in the packet
+    def extract_opts(key_list = [:POST, :GET, 'route.resource_path'])
+      opts = {}
+      key_list.reverse.each do |key|
+        case key
+        when :GET then opts.merge! packet.request.GET
+        when :POST then opts.merge! packet.request.POST
+        else 
+          opts.merge!(packet[key, {}].kind_of?(String) ? url_to_hash(packet[key]) : packet[key, {}])
+        end
+      end
+      opts
+    end
+    
+    # Converts a url path to a hash with symbol keys. URL must
+    # be in /key/val/key/val/etc format
+    def url_to_hash(url)
+      parts = url.split('/')
+      hash = {}
+      while !parts.blank?
+        key = parts.shift
+        key = parts.shift if key.blank?
+        val = parts.shift
+        hash[key.to_sym] = val unless key.blank? or val.blank?
+      end
+      hash
+    end
+    
+    # Method Missing allows defining custom methods
+    def method_missing(id, *args)
+      matched = false
+      id = id.to_s
+      @@matchers.each_key do |k|
+        matched = k if id =~ k
+        break if matched
+      end
+      return @@matchers[matched].call(packet, matched.match(id), args) if matched
+      raise NoMethodError.new("No method ##{id} found", id)
+    end
+  end
+end