orange 0.5.5 → 0.5.7

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

@@ -1,17 +0,0 @@
-require 'orange-core/middleware/base'
-module Orange::Middleware
-  
-  class Globals < Base
-    def init(opts = {})
-      opts = opts.with_defaults(:file => "__ORANGE__/config.yml")
-      @file = opts[:file].gsub('__ORANGE__', orange.app_dir)
-      @globals = orange[:parser].yaml(@file) || {}
-      @globals.each{|k,v| orange.options[k] = v}
-    end
-    def packet_call(packet)
-      packet['orange.globals'] ||= orange.options
-      pass packet
-    end
-    
-  end
-end

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

@@ -1,13 +0,0 @@
-require 'orange-core/middleware/base'
-module Orange::Middleware
-  class Loader < Base
-    def init(*args)
-      Dir.glob(File.join(orange.app_dir, 'resources', '*.rb')).each do |f| 
-        require f 
-        orange.load Orange::Inflector.constantize(Orange::Inflector.camelize(File.basename(f, '.rb'))).new
-      end
-      Dir.glob(File.join(orange.app_dir, 'cartons', '*.rb')).each { |f|  require f }
-      Dir.glob(File.join(orange.app_dir, 'middleware', '*.rb')).each { |f|  require f }
-    end
-  end  
-end

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

@@ -1,53 +0,0 @@
-require 'orange-core/middleware/base'
-module Orange::Middleware
-  
-  class Rerouter < Base
-    def init(*args)
-      orange.add_pulp Orange::Pulp::Packet_Reroute
-    end
-    
-    def packet_call(packet)
-      begin
-        pass packet
-      rescue Orange::Reroute
-        packet.finish
-      end
-    end
-  end
-end
-
-module Orange
-  
-  module Pulp::Packet_Reroute
-    def reroute(url, type = :real, *args)
-      packet['reroute.to'] = url
-      packet['reroute.type'] = type
-      packet['reroute.args'] = *args if args
-      raise Reroute.new(self), 'Unhandled reroute'
-    end
-  end
-  
-  class Reroute < Exception
-    def initialize(packet)
-      @packet = packet
-      @packet[:headers] = {"Content-Type" => 'text/html', "Location" => self.url}
-      @packet[:status] = 302
-    end
-    
-    def url
-      case packet['reroute.type']
-      when :real
-        packet['reroute.to']
-      # Parsing for orange urls or something
-      when :orange
-        packet.route_to(packet['reroute.to'], *packet['reroute.args', []])
-      else
-        packet['reroute.to']
-      end
-    end
-    
-    def packet
-      @packet
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-require 'orange-core/middleware/base'
-
-module Orange::Middleware
-  class RestfulRouter < Base
-    def init(*args)
-      opts = args.extract_options!.with_defaults(:restful_contexts => [:admin, :orange], :not_found => false, :exposed_actions => {:admin => :all, :orange => :all})
-      @exposed = opts[:exposed_actions]
-      @contexts = opts[:restful_contexts]
-      @not_found = opts[:not_found]
-    end
-    
-    # sets resource, resource_id, resource_action and resource_path
-    # /resource/id/action/[resource/path/if/any]
-    # /resource/action/[resource/path/if/any]
-    # 
-    # In future - support for nested resources
-    def packet_call(packet)
-      return (pass packet) if packet['route.router']  # Don't route if other middleware
-                                                      # already has
-      parts = route_parts(packet)
-      if(should_route?(packet, parts))
-        # Take parts of route and set packet info
-        packet['route.resource'] = parts[:resource] if parts[:resource]
-        packet['route.resource_id'] = parts[:resource_id] if parts[:resource_id]
-        packet['route.resource_action'] = parts[:resource_action] if parts[:resource_action]
-        
-        # Take remainder and set to resource_path
-        packet['route.resource_path'] = parts[:remainder]
-        
-        # Set self as router if resource was found
-        if(packet['route.resource', false]) 
-          packet['route.router'] = self
-        elsif(@not_found)
-          packet['route.resource'] = @not_found
-          packet['route.router'] = self
-        end
-      end 
-      
-      pass packet
-    end
-    
-    def route_parts(packet)
-      return_parts = {}
-      path = packet['route.path'] || packet.request.path_info
-      parts = path.split('/')
-      pad = parts.shift
-      if !parts.empty?
-        resource = parts.shift
-        if orange.loaded?(resource.to_sym)
-          return_parts[:resource] = resource.to_sym
-          if !parts.empty?
-            second = parts.shift
-            if second =~ /^\d+$/
-              return_parts[:resource_id] = second
-              if !parts.empty?
-                return_parts[:resource_action] = parts.shift.to_sym
-              else
-                return_parts[:resource_action] = :show
-              end
-            else
-              return_parts[:resource_action] = second.to_sym
-            end 
-          else
-            return_parts[:resource_action] = :list
-          end # end check for second part
-        else
-          parts.unshift(resource)
-        end # end check for loaded resource
-      end # end check for nonempty route
-      return_parts[:remainder] = parts.unshift(pad).join('/')
-      return_parts
-    end
-    
-    def should_route?(packet, parts)
-      return false unless @exposed.has_key?(packet['route.context'])
-      action_exposed?(@exposed[packet['route.context']], parts)      
-    end
-    
-    def action_exposed?(list, route_parts)
-      return true if list == :all
-      return true if list == route_parts[:resource_action]
-      return true if list.is_a?(Array) && list.include?(route_parts[:resource_action])
-      if list.is_a?(Hash)
-        all = list.has_key?(:all) ? action_exposed?(list[:all], route_parts) : false
-        one = list.has_key?(route_parts[:resource]) ? action_exposed?(list[route_parts[:resource]], route_parts) : false
-        return all || one
-      end
-      false
-    end
-    
-    def route(packet)
-      resource = packet['route.resource']
-      raise 'resource not found' unless orange.loaded? resource
-      mode = packet['route.resource_action'] || 
-        (packet['route.resource_id'] ? :show : :list)
-      packet[:content] = orange[resource].view packet
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-require 'orange-core/middleware/base'
-
-module Orange::Middleware
-  # This middleware handles setting orange.env['route.context'] 
-  # to a value based on the route, if any. The route is then 
-  # trimmed before continuing on.
-  class RouteContext < Base
-    def initialize(app, core, *args)
-      opts = args.extract_options!
-      opts.with_defaults!(:contexts => [:preview, :live, :admin, :orange], 
-                          :default => :live,
-                          :urls => {})
-      @app = app
-      @core = core
-      @contexts = opts[:contexts]
-      @default = opts[:default]
-      @urls = opts[:urls]
-    end
-    def packet_call(packet)
-      path_info = packet['route.path'] || packet.env['PATH_INFO']
-      path = path_info.split('/')
-      pad = path.shift # Shift off empty first part
-      if @urls[packet.request.host]
-        packet['route.context'] = urls[packet.request.host]
-      elsif path.empty?
-        packet['route.context'] = @default
-      else
-        if(@contexts.include?(path.first.to_sym))
-          packet['route.context'] = path.shift.to_sym
-          path.unshift(pad)
-          packet['route.path'] = path.join('/')
-        else
-          packet['route.context'] = @default
-        end
-      end
-      pass packet
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-require 'orange-core/middleware/base'
-
-module Orange::Middleware
-  # This middleware handles setting orange.env['route.site_url'] 
-  # to a value based on the route, if any. The route is then 
-  # trimmed before continuing on.
-  # 
-  # Options - 
-  #   :multi   - does Orange need to handle multiple urls
-  #   :fake_it - host url(s) that Orange will fake requests on
-  #               ex: :multi => true, :fake_it => 'localhost'
-  #                   will fake hostnames as first component of url
-  #                   only on localhost
-  class RouteSite < Base
-    def initialize(app, core, *args)
-      opts = args.extract_options!
-      opts.with_defaults!(:multi => false, :fake_it => ['localhost'])
-      @app = app
-      @core = core
-      @multi = opts[:multi]
-      # Put fake_it into an array, if necessary
-      @fake_it = opts[:fake_it].respond_to?(:include?) ? 
-        opts[:fake_it] : [opts[:fake_it]]
-    end
-    
-    def packet_call(packet)
-      request = packet.request
-      path_info = packet['route.path'] || packet.env['PATH_INFO']
-      path = path_info.split('/')
-      pad = path.shift # Shift off empty first part
-      packet['route.faked_site'] = false
-      if @multi
-        if path.empty?
-          packet['route.site_url'] = request.host
-        else
-          if @fake_it.include?(request.host)
-            packet['route.site_url'] = path.shift
-            packet['route.faked_site'] = true
-          else
-            packet['route.site_url'] = request.host
-          end
-          path.unshift(pad)
-          packet['route.path'] = path.join('/')
-        end
-      else
-        packet['route.site_url'] = request.host
-      end
-      pass packet
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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