orange 0.5.5 → 0.5.7

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

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

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

data/lib/orange-core/plugin.rb

@@ -1,172 +0,0 @@
-require 'orange-core/magick'
-require 'orange-core/core'
-module Orange::Plugins
-  # This class defines a basic Orange plugin. A plugin simply defines
-  # a bunch of possible classes/files that can be called up by the main
-  # orange system.
-  # 
-  # The plugins are used in several places. When the core is initialized,
-  # it will ask all plugins if they have any resources that should be added,
-  # and load those resources if they exist.
-  # 
-  # The stack will call the list of plugins several times in building a stack
-  # once for each possible middleware location. 
-  class Base
-    extend ClassInheritableAttributes
-    cattr_accessor  :prerouting_middleware, :routing_middleware, 
-                    :responder_middleware, :postrouting_middleware, :has_middleware
-    cattr_accessor :assets, :assets_name
-    cattr_accessor :resources
-    cattr_accessor :views
-    cattr_accessor :templates
-    
-    # Adds a single prerouting middleware class to list of prerouting middleware
-    def self.prerouter(r)
-      prerouters(r)
-    end
-    
-    # Adds several prerouting middleware classes to list of prerouting middleware
-    def self.prerouters(*routers)
-      self.has_middleware = true
-      routers.each do |prerouter|
-        self.prerouting_middleware << prerouter
-      end
-    end
-    
-    # Adds a single postrouting middleware class to list of postrouting middleware
-    def self.postrouter(r)
-      postrouters(r)
-    end
-    
-    # Adds several postrouting middleware classes to list of postrouting middleware
-    def self.postrouters(*routers)
-      self.has_middleware = true
-      routers.each do |postrouter|
-        self.postrouting_middleware << postrouter
-      end
-    end
-    
-    # Adds a router middleware class to the list of routing middleware
-    def self.router(r)
-      routers(r)
-    end
-    # Adds several router middleware classes
-    def self.routers(*routers)
-      self.has_middleware = true
-      routers.each do |router|
-        self.routing_middleware << router
-      end
-    end
-    # Adds a responder middleware class 
-    def self.responder(r)
-      responders(r)
-    end
-    # Adds several responder middleware classes
-    def self.responders(*respones)
-      self.has_middleware = true
-      respones.each do |response|
-        self.responder_middleware << response
-      end
-    end
-    
-    # Returns the list of prerouting_middleware defined or
-    # an empty array if none defined
-    def self.prerouting_middleware
-      super || self.prerouting_middleware = []
-    end
-    
-    # Returns the list of prerouting_middleware defined or
-    # an empty array if none defined
-    def self.postrouting_middleware
-      super || self.postrouting_middleware = []
-    end
-    
-    # Returns the list of routing_middleware defined or
-    # an empty array if none defined
-    def self.routing_middleware
-      super || self.routing_middleware = []
-    end
-    
-    # Returns the list of responder_middleware defined or
-    # an empty array if none defined
-    def self.responder_middleware
-      super || self.responder_middleware = []
-    end
-    
-    def self.templates_dir(arg)
-      self.templates = arg
-    end
-    
-    def self.views_dir(arg)
-      self.views = arg
-    end
-    
-    def self.assets_dir(arg)
-      self.assets = arg
-    end
-    
-    def self.resource(instance, name = false)
-      self.resources << [instance, name]
-    end
-    
-    def self.resources
-      super || self.resources = []
-    end
-    
-    # Returns the assigned asset dir name,
-    # or Plugin class name formatted like this: PluginClass -> _pluginclass_
-    def assets_name
-      self.class.assets_name || '_'+self.class.to_s.gsub(/Orange::Plugins::/, '').gsub(/::/, '_').downcase+'_'
-    end
-    
-    # Returns the assets directory for this plugin
-    def assets
-      self.class.assets
-    end
-    
-    # Whether this plugin has assets for the static middleware to worry
-    # about
-    def has_assets?
-      !assets.blank?
-    end
-    
-    def resources
-      self.class.resources
-    end
-    
-    def has_resources?
-      !resources.blank?
-    end
-    
-    def views
-      self.class.views
-    end
-    
-    def has_views?
-      !views.blank?
-    end
-    
-    def templates
-      self.class.templates
-    end
-    
-    def has_templates?
-      !templates.blank?
-    end
-    
-    def middleware(type = :has)
-      case type
-      when :responders then self.class.responder_middleware
-      when :routing then self.class.routing_middleware
-      when :prerouting then self.class.prerouting_middleware
-      when :postrouting then self.class.postrouting_middleware
-      when :has then self.class.has_middleware
-      else nil
-      end
-    end
-    
-    def has_middleware?
-      !middleware.blank?
-    end
-  end
-end