orange-core 0.5.3

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

@@ -0,0 +1,96 @@
+require 'orange-core/packet'
+
+# Orange Middleware is a bit more complex than Rack middleware. 
+# Initializing it requires both a link to the downstream app and 
+# the core, and calling the app often requires an Orange::Packet
+#
+# Orange::Middleware::Base takes care of these basic tasks.
+# Subclasses override the init method for extra initialization
+# and the packet_call for a call with a packet, rather than
+# a basic call
+module Orange::Middleware
+  class Base
+    # Initialize will set the core and downstream app, then call init
+    # subclasses should override init instead of initialize.
+    # If the subclass defines a stack_init, then it will be registered
+    # as a stack_loaded event.
+    # @param [Object] app a downstream app 
+    # @param [Orange::Core] core the orange core
+    # @param [optional, Array] args any arguments
+    def initialize(app, core, *args)
+      @app = app
+      @core = core
+      init(*args)
+      core.middleware(self)
+    end
+    
+    # A stub method that subclasses can override to handle initialization
+    # For initialization
+    # @return [void]
+    def init(*args)
+    end
+    
+    # The standard Rack "call". By default, Orange Middleware wraps the env into
+    # an Orange::Packet and passes it on to #packet_call. Subclasses will typically
+    # override packet_call rather than overriding call directly. 
+    # 
+    # Orange Middleware
+    # should expect to have this method ignored by upstream Orange-aware apps in
+    # favor of calling packet_call directly.
+    # @param [Hash] env the hash of environment variables given by the rack interface.
+    # @return [Array] the standard Rack striplet of status, headers and content
+    def call(env)
+      packet = Orange::Packet.new(@core, env)
+      packet_call(packet)
+    end
+    
+    # Like the standard call, but with the env hash already wrapped into a Packet
+    # This is called automatically as part of #call, so subclasses can have a packet
+    # without having to initialize it. It will be called directly by Orange-aware
+    # upstream middleware, skipping the step of initializing the packet during #call.
+    # 
+    # Passing the packet downstream should be done with #pass rather than the Rack
+    # standard @app.call, since #pass will take the packet and do a #packet_call
+    # if possible.
+    # @param [Orange::Packet] packet the packet corresponding to this env
+    # @return [Array] the standard Rack striplet of status, headers and content
+    def packet_call(packet)
+      pass packet
+    end
+    
+    # Pass will sent the packet to the downstream app by calling call or packet call.
+    # Calling pass on a packet is the preferred way to call downstream apps, as it
+    # will call packet_call directly if possible (to avoid reinitializing the packet)
+    # @param [Orange::Packet] packet the packet to pass to downstream apps
+    # @return [Array] the standard Rack striplet of status, headers and content
+    def pass(packet)
+      if @app.respond_to?(:packet_call)
+        @app.packet_call(packet)
+      else
+        recapture(@app.call(packet.env), packet)
+      end
+    end
+    
+    # After the pass has been completed, we should recapture the contents and make
+    # sure they are placed in the packet, in case the downstream app is not Orange aware.
+    # @param [Array] the standard Rack striplet of status, headers and content
+    # @param [Orange::Packet] packet the packet to pass to downstream apps
+    # @return [Array] the standard Rack striplet of status, headers and content
+    def recapture(response, packet)
+      packet[:status]  = response[0]
+      packet[:headers] = response[1]
+      packet[:content] = response[2].first
+      response
+    end
+    
+    # Accessor for @core, which is the stack's instance of Orange::Core
+    # @return [Orange::Core] the stack's instance of Orange::Core
+    def orange;     @core;    end
+    
+    # Help stack traces
+    # @return [String] string representing this middleware (#to_s)
+    def inspect
+      self.to_s
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'orange-core/middleware/base'
+module Orange::Middleware
+  
+  class Database < Base
+    def init(opts = {})
+      opts = opts.with_defaults(:migration_url => (orange.options[:development_mode] ? '/__ORANGE_DB__/migrate' : false), :no_auto_upgrade => false)
+      orange.mixin Orange::Mixins::DBLoader
+      @options = opts
+    end
+    
+    def stack_init
+      unless orange.options.has_key?('database') && orange.options['database'] == false
+        db = orange.options['database'] || 'sqlite3::memory:'
+        orange.load_db!(db) 
+        orange.upgrade_db! unless @options[:no_auto_upgrade] || orange.options['db_no_auto_upgrade']
+      end
+    end
+    
+    def packet_call(packet)
+      path = packet['route.path'] || packet.request.path_info
+      if @options[:migration_url] && @options[:migration_url] == path
+        orange.migrate_db!
+        after = packet.flash('redirect_to') || '/'
+        packet.reroute(after)
+      end
+      pass packet
+    end
+  end
+  
+end
+
+module Orange::Mixins::DBLoader
+  def load_db!(url)
+    DataMapper.setup(:default, url)
+  end
+  
+  def migrate_db!
+    DataMapper.auto_migrate!
+  end
+  
+  def upgrade_db!
+    DataMapper.auto_upgrade!
+  end
+  
+end

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

@@ -0,0 +1,45 @@
+require 'orange-core/middleware/base'
+
+module Orange::Middleware
+  # The FlexRouter middleware takes a resource that can route paths and
+  # then intercepts routes for that resource. By default,
+  # it uses the Orange::SitemapResource. 
+  # 
+  # The resource is automatically loaded into the core as 
+  # :sitemap. The resource must respond to "route?(path)" 
+  # and "route(packet)".  
+  # 
+  # Pass a different routing resource using the :resource arg
+  class FourOhFour < Base
+    def init(opts = {})
+      @resource = opts[:resource] || Orange::NotFound
+      orange.load @resource.new, :not_found
+      orange.add_pulp Orange::Pulp::NotFoundHelper
+    end
+    
+    # Sets the sitemap resource as the router if the resource can accept 
+    # the path.
+    def packet_call(packet)
+      packet['route.router'] = orange[:not_found] unless packet['route.router']
+      begin
+        pass packet
+      rescue Orange::NotFoundException
+        orange[:not_found].route(packet)
+        packet.finish
+      end
+    end
+    
+  end
+end
+
+module Orange
+  class NotFoundException < Exception
+    
+  end
+  
+  module Pulp::NotFoundHelper
+    def not_found
+      raise Orange::NotFoundException.new
+    end
+  end
+end

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

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

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

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

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

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

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