orange 0.0.2

data/lib/orange/magick.rb

@@ -0,0 +1,91 @@
+# Monkey Patch the extract_options! stolen from ActiveSupport
+class ::Array
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+  def extract_with_defaults(defaults)
+    extract_options!.with_defaults(defaults)
+  end
+end
+
+# Monkey Patch for merging defaults into a hash 
+class ::Hash
+  def with_defaults(defaults)
+    self.merge(defaults){ |key, old, new| old.nil? ? new : old } 
+  end
+  def with_defaults!(defaults)
+    self.merge!(defaults){ |key, old, new| old.nil? ? new : old } 
+  end
+end
+
+
+
+# Monkey patch for awesome array -> hash conversions
+# use:
+#
+# [:x, :y, :z].inject_hash do |results, letter|
+#   results[letter] = rand(100)
+# end
+#
+# => {:x => 32, :y => 63, :z => 91}
+module Enumerable
+  def inject_hash(hash = {}) 
+    inject(hash) {|(h,item)| yield(h,item); h}
+  end 
+end
+
+module ClassInheritableAttributes
+  def cattr_inheritable(*args)
+    @cattr_inheritable_attrs ||= [:cattr_inheritable_attrs]
+    @cattr_inheritable_attrs += args
+    args.each do |arg|
+      class_eval %(
+        class << self; attr_accessor :#{arg} end
+      )
+    end
+    @cattr_inheritable_attrs
+  end
+
+  def inherited(subclass)
+    @cattr_inheritable_attrs.each do |inheritable_attribute|
+      instance_var = "@#{inheritable_attribute}" 
+      subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
+    end
+  end
+end
+
+module Orange
+  
+  # Class that extends hash so that [] can have an optional second attribute
+  class DefaultHash < ::Hash
+    def [](key, my_default = nil)
+      my_default = self.default if my_default.nil?
+      self.has_key?(key) ? super(key) : my_default
+    end
+  end
+  
+  # Simple class for evaluating options and allowing us to access them.
+  class Options
+    
+    def initialize(*options, &block)
+      @options = options.extract_options!
+      @options ||= {}
+      instance_eval(&block) if block_given?
+    end
+    
+    def hash
+      @options
+    end
+
+    def method_missing(key, *args)
+      return (@options[key.to_s.gsub(/\?$/, '').to_sym].eql?(true)) if key.to_s.match(/\?$/)
+      if args.empty?
+        @options[key.to_sym]
+      elsif(key.to_s.match(/\=$/))
+        @options[key.to_s.gsub(/\=$/, '').to_sym] = (args.size == 1 ? args.first : args)
+      else
+        @options[key.to_sym] = (args.size == 1 ? args.first : args)
+      end
+    end
+  end
+end

data/lib/orange/middleware/access_control.rb

@@ -0,0 +1,100 @@
+require 'orange/middleware/base'
+
+
+
+module Orange::Middleware
+  
+  class AccessControl < Base
+    def init(*args)
+      defs = {:locked => [:admin, :orange], :login => '/login', 
+              :handle_login => true, :openid => true, :config_id => true}
+      opts = args.extract_with_defaults(defs)
+      @openid = opts.has_key?(:openid) ? opts[:openid] : false
+      @locked = opts[:locked]
+      @login = opts[:login]
+      @handle = opts[:handle_login]
+      @single = opts[:config_id]
+    end
+      
+    def packet_call(packet)
+      packet['user.id'] ||= (packet.session['user.id'] || false)
+      if @openid && need_to_handle?(packet)
+        ret = handle_openid(packet)
+        return ret if ret # unless handle_openid returns false, exit immediately
+      end
+      unless access_allowed?(packet)
+        packet.session['user.after_login'] = packet.request.path
+        packet.reroute(@login)
+      end
+      
+      pass packet
+    end
+    
+    def access_allowed?(packet)
+      return true unless @locked.include?(packet['route.context'])
+      if packet['user.id']
+        if @single && (packet['user.id'] == packet['orange.globals']['main_user'])
+          true
+        elsif @single
+          # Current id no good. 
+          packet['user.id'] = false
+          packet.session['user.id'] = false
+          false
+        else
+          true
+        end
+      else
+        false
+      end
+    end
+    
+    def need_to_handle?(packet)
+      @handle && (packet.env['REQUEST_PATH'] == @login)
+    end
+    
+    def handle_openid(packet)
+      packet.reroute('/') if packet['user.id'] # Reroute to index if we're logged in.
+      # If login set
+      if packet.request.post?
+        packet['template.disable'] = true
+        # Check for openid response
+        if resp = packet.env["rack.openid.response"]
+          if resp.status == :success
+            packet['user.id'] = resp.identity_url
+            packet['user.openid.url'] = resp.identity_url
+            packet['user.openid.response'] = resp
+            
+            after = packet.session.has_key?('user.after_login') ?
+                        packet.session['user.after_login'] : false
+            packet.session['user.after_login'] = false
+            
+            # Save id into session if we have one.
+            packet.session['user.id'] = packet['user.id']
+            
+            # If the user was supposed to be going somewhere, redirect there
+            packet.reroute(after) if after
+            packet.reroute('/')
+            false
+          else
+            packet.session['flash.error'] = resp.status
+            packet.reroute(@login)
+            false
+          end
+        # Set WWW-Authenticate header if awaiting openid.response
+        else
+          packet[:status] = 401
+          packet[:headers] = {}
+          packet.add_header('WWW-Authenticate', Rack::OpenID.build_header(
+                :identifier => packet.request.params["openid_identifier"]
+              ))
+          packet[:content] = 'Got openID?'
+          packet.finish
+        end
+      # Show login form, if necessary
+      else
+        packet[:content] = orange[:parser].haml('openid_login.haml', packet)
+        packet.finish
+      end
+    end # end handle_openid
+  end
+end

data/lib/orange/middleware/base.rb

@@ -0,0 +1,41 @@
+require 'orange/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
+    def initialize(app, core, *args)
+      @app = app
+      @core = core
+      init(*args)
+    end
+    
+    def init(*args)
+    end
+    
+    def call(env)
+      packet = Orange::Packet.new(@core, env)
+      packet_call(packet)
+    end
+    
+    def packet_call(packet)
+      pass packet
+    end
+    
+    def pass(packet)
+      @app.call(packet.env)
+    end
+    
+    def orange;     @core;    end
+    
+    def inspect
+      self.to_s
+    end
+  end
+end

data/lib/orange/middleware/database.rb

@@ -0,0 +1,22 @@
+require 'orange/middleware/base'
+module Orange::Middleware
+  
+  class Database < Base
+    def init(*args)
+      orange.mixin Orange::Mixins::DBLoader
+    end
+    def packet_call(packet)
+      db = packet['orange.globals']['database'] || 'sqlite3::memory:'
+      orange.load_db!(db)
+      pass packet
+    end
+  end
+  
+end
+
+module Orange::Mixins::DBLoader
+  def load_db!(url)
+    DataMapper.setup(:default, url)
+    DataMapper.auto_upgrade!
+  end
+end

data/lib/orange/middleware/globals.rb

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

data/lib/orange/middleware/recapture.rb

@@ -0,0 +1,19 @@
+require 'orange/middleware/base'
+module Orange::Middleware
+  
+  # Middleware to recapture return info and put it back into the
+  # packet. Since the Orange::Stack is all middleware, this is
+  # important for adding after filters into the orange stack
+  # that can interact with the returns of external apps
+  class Recapture < Base
+    
+    def packet_call(packet)
+      ret = pass packet
+      packet[:status]  = ret[0]
+      packet[:headers] = ret[1]
+      packet[:content] = ret[2].first
+      ret
+    end
+    
+  end
+end

data/lib/orange/middleware/rerouter.rb

@@ -0,0 +1,13 @@
+require 'orange/middleware/base'
+module Orange::Middleware
+  
+  class Rerouter < Base
+    def packet_call(packet)
+      begin
+        pass packet
+      rescue Orange::Reroute
+        packet.finish
+      end
+    end
+  end
+end

data/lib/orange/middleware/restful_router.rb

@@ -0,0 +1,59 @@
+require 'orange/middleware/base'
+
+module Orange::Middleware
+  class RestfulRouter < Base
+    def init(*args)
+      opts = args.extract_options!.with_defaults(:contexts => [:admin, :orange], :root_resource => :not_found)
+      @contexts = opts[:contexts]
+      @root_resource = opts[:root_resource]
+    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
+      if(@contexts.include?(packet['route.context']))
+        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)
+            packet['route.resource'] = resource.to_sym
+            if !parts.empty?
+              second = parts.shift
+              if second =~ /^\d+$/
+                packet['route.resource_id'] = second
+                if !parts.empty?
+                  packet['route.resource_action'] = parts.shift.to_sym
+                end
+              else
+                packet['route.resource_action'] = second.to_sym
+              end 
+            end # end check for second part
+          else
+            parts.unshift(resource)
+          end # end check for loaded resource
+        end # end check for nonempty route
+        
+        packet['route.resource'] ||= @root_resource
+        packet['route.resource_path'] = parts.unshift(pad).join('/')
+        packet['route.router'] = self
+      end # End context match if
+      
+      pass packet
+    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/middleware/route_context.rb

@@ -0,0 +1,39 @@
+require 'orange/middleware/base'
+
+module Orange::Middleware
+  # This middleware handles setting orange.env[: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 => [: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
+      @app.call(packet.env)
+    end
+  end
+end

data/lib/orange/middleware/route_site.rb

@@ -0,0 +1,51 @@
+require 'orange/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
+      @app.call(packet.env)
+    end
+  end
+end