orange 0.0.2

data/lib/orange/packet.rb

@@ -0,0 +1,88 @@
+module Orange
+  # 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
+    DEFAULT_HEADERS = {"Content-Type" => 'text/html'} unless defined?(DEFAULT_HEADERS)
+    
+    def self.new(orange, env)
+      return env['orange.packet'] if env['orange.packet']
+      super(orange, env)
+    end
+    
+    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
+    
+    def [](key, default = false)
+      @env['orange.env'].has_key?(key) ? @env['orange.env'][key] : default
+    end
+    
+    def []=(key, val)
+      @env['orange.env'][key] = val
+    end
+    
+    def env
+      @env
+    end
+    
+    def session
+      env['rack.session']
+    end
+    
+    def headers
+      packet[:headers, {}].with_defaults(DEFAULT_HEADERS)
+    end
+    def header(key, val)
+      @env['orange.env'][:headers][key] = val
+    end
+    
+    def add_header(key, val)
+      header key, val
+    end
+    
+    def content
+      return [packet[:content]] if packet[:content]
+      return []
+    end
+    
+    def request
+      packet[:request]
+    end
+    
+    def orange
+      @orange
+    end
+    
+    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
+    
+    def packet
+      self
+    end
+    
+    def self.mixin(inc)
+      include inc
+    end
+    
+    def route
+      router = packet['route.router']
+      raise 'Router not found' unless router
+      router.route(self)
+    end
+  end
+  
+end

data/lib/orange/resource.rb

@@ -0,0 +1,37 @@
+require 'orange/core'
+
+module Orange
+  # Orange Resource for being subclassed
+  class Resource
+    def initialize(*args, &block)
+      @options = Options.new(args, &block).hash
+    end
+    
+    def set_orange(orange, name)
+      @orange = orange
+      @my_orange_name = name
+      afterLoad
+      self
+    end
+    
+    def self.set_orange(*args)
+      raise 'trying to call set orange on a class (you probably need to instantiate a resource)'
+    end
+    
+    def afterLoad
+      true
+    end
+    
+    def orange
+      @orange
+    end
+    
+    def routable
+      false
+    end
+    
+    def view(packet = false)
+      ''
+    end
+  end
+end

data/lib/orange/resources/flex_router.rb

@@ -0,0 +1,13 @@
+require 'orange/core'
+require 'dm-is-nested_set'
+module Orange
+  class FlexRouter
+    
+  end
+  
+  class Route < SiteCarton
+    id
+    
+    is :nested_set, :scope => [:orange_site_id]
+  end
+end

data/lib/orange/resources/mapper.rb

@@ -0,0 +1,55 @@
+require 'orange/core'
+
+module Orange
+  class Mapper < Resource
+    # Takes a packet extracts request information, then calls packet.route
+    def afterLoad
+      orange.add_pulp Pulp::Packet_Mapper
+    end
+    
+    def route_to(packet, resource, *args)
+      context = packet['route.context', nil]
+      site = packet['route.faked_site'] ? packet['route.site_url', nil] : nil
+      args.unshift(resource)
+      args.unshift(context)
+      args.unshift(site)
+      '/'+args.compact.join('/')
+    end
+  end
+  
+  module Pulp::Packet_Mapper
+    def route_to(resource, *args)
+      orange[:mapper].route_to(self, resource, *args)
+    end
+    
+    def reroute(url, type = :real)
+      packet['reroute.to'] = url
+      packet['reroute.type'] = type
+      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'])
+      end
+    end
+    
+    def packet
+      @packet
+    end
+  end
+  
+end

data/lib/orange/resources/page_parts.rb

@@ -0,0 +1,54 @@
+module Orange
+  class PageParts < Resource
+    def afterLoad
+      orange.add_pulp Orange::Pulp::PageParts
+    end
+  end
+  
+  module Pulp::PageParts
+    
+    def part
+      unless packet[:page_parts, false]
+        packet[:page_parts] = DefaultHash.new 
+        packet[:page_parts].default = ''
+      end
+      packet[:page_parts]
+    end
+    
+    # Feels like part should be plural, no?
+    def parts;    part;     end
+    
+    def admin_sidebar_link(section, *args)
+      args = args.extract_options!.with_defaults(:position => 0)
+      sidebar = part[:admin_sidebar, {}]
+      sidebar[section] = [] unless sidebar.has_key?(section)
+      sidebar[section].insert(args[:position], {:href => args[:link], :text => args[:text]})
+      part[:admin_sidebar] = sidebar
+    end
+    
+    def add_css(file, opts = {})
+      ie = opts[:ie] || false
+      mod = opts[:module] || 'public'
+        # module set to false gives the root assets dir
+      assets = File.join('assets', mod)
+      file = File.join('', assets, 'css', file)
+      if ie
+        part[:ie_css] = part[:ie_css] + "<link rel=\"stylesheet\" href=\"#{file}\" type=\"text/css\" media=\"screen\" charset=\"utf-8\" />"
+      else 
+        part[:css] = part[:css] + "<link rel=\"stylesheet\" href=\"#{file}\" type=\"text/css\" media=\"screen\" charset=\"utf-8\" />"
+      end
+    end
+    
+    def add_js(file, opts = {})
+      ie = opts[:ie] || false
+      mod = opts[:module] || 'public'
+      assets = File.join('assets', mod)
+      file = File.join('', assets, 'js', file)
+      if ie
+        part[:ie_js] = part[:ie_js] + "<script src=\"#{file}\" type=\"text/javascript\"></script>"
+      else 
+        part[:js] = part[:js] + "<script src=\"#{file}\" type=\"text/javascript\"></script>"
+      end
+    end
+  end
+end

data/lib/orange/resources/parser.rb

@@ -0,0 +1,60 @@
+require 'orange/core'
+require 'haml'
+require 'yaml'
+require 'hpricot'
+
+module Orange
+  class Parser < Resource
+    def afterLoad
+      orange.add_pulp Orange::Pulp::ParserPulp
+    end
+    
+    def yaml(file)
+      string = File.read(file)
+      string.gsub!('__ORANGE__', orange.app_dir)
+      out = YAML::load(string)
+    end
+    
+    def haml(file, packet, *vars, &block)
+      opts = vars.extract_options!
+      temp = opts.delete(:template)
+      resource = (opts[:resource] || '').downcase
+      opts.merge :orange => orange
+      
+      templates_dir = File.join(orange.core_dir, 'templates')
+      views_dir = File.join(orange.core_dir, 'views')
+      default_dir = File.join(views_dir, 'default_resource')
+      
+      string = false
+      string ||= read_if('templates', file) if temp
+      string ||= read_if(templates_dir, file) if temp
+      string ||= read_if('views', resource, file) if resource
+      string ||= read_if('views', file)
+      string ||= read_if(views_dir, file)
+      string ||= read_if(views_dir, 'default_resource', file)
+      raise LoadError, "Couldn't find haml file '#{file}" unless string
+      
+      haml_engine = Haml::Engine.new(string)
+      out = haml_engine.render(packet, opts, &block)
+    end
+    
+    def read_if(*args)
+      return File.read(File.join(*args)) if File.exists?(File.join(*args))
+      false
+    end
+    
+    def hpricot(text)
+      Hpricot(text)
+    end
+  end 
+  
+  module Pulp::ParserPulp
+    def html(&block)
+      if block_given?
+        doc = orange[:parser].hpricot(packet[:content])
+        yield doc
+        packet[:content] = doc.to_s
+      end
+    end
+  end
+end

data/lib/orange/routable_resource.rb

@@ -0,0 +1,16 @@
+require 'orange/resource'
+
+module Orange
+  class RoutableResource < Resource
+    def routable; true; end
+    
+    def route(path, packet)
+      parts = path.split('/')
+      first = parts[0].respond_to?(:to_sym) ? parts.shift.to_sym : :index
+      new_path = parts.join('/')
+      if self.respond_to?(first)
+        packet[:content] = self.__send__(first, new_path, packet)
+      end
+    end
+  end
+end

data/lib/orange/stack.rb

@@ -0,0 +1,201 @@
+require 'orange/core'
+require 'rack/builder'
+module Orange
+  # Builds an orange stack of middleware
+  # Use in the rackup file as follows:
+  # app = Orange::Stack.new do 
+  #    stack Orange::DataMapper 'sqlite3::memory:'  <= loads orange specific middleware
+  #    use OtherMiddleware
+  #    run SomeApp.new
+  # end
+  # run app
+  #
+  # All middleware placed inside the Orange::Stack will have access
+  # to the Orange Core (as long as it's been written to accept it as the second
+  # initialization argument) when added with the 'stack' method
+  # 
+  # In general, Orange::Stack works like Rack::Builder.
+  class Stack
+    
+    # Creates a new Orange::Stack out of the passed block.
+    # 
+    # If a block is not passed, it will try to build one from scratch.
+    # The bare minimum will be `run app_class.new(@core)`, there are also
+    # other stacks that can be used.
+    #
+    # @param [Orange::Application] app_class the class of the main application
+    # @param [prebuilt] prebuilt the optional prebuilt stack, if one isn't passed as block
+    def initialize(app_class = nil, prebuilt = :none, &block)
+      @build = Rack::Builder.new
+      @core = Orange::Core.new
+      @auto_reload = false
+      @recapture = true
+      @main_app = app_class
+      if block_given?
+        instance_eval(&block) 
+      else
+        @main_app = app_class.new(@core) unless app_class.nil? 
+        prebuild(prebuilt)
+      end
+    end
+    
+    # Runs methods necessary to build a stack. Don't use if a stack
+    # has already been built by the initialize block.
+    #
+    # @todo Offer more choices for default stacks
+    def prebuild(choice)
+      case choice
+      when :none
+        no_recapture
+        run @main_app
+      else
+        no_recapture
+        run @main_app
+      end
+    end
+    
+    # Returns the main application instance that was added by the 
+    # run method. Obviously won't return anything useful if the
+    # middleware stack hasn't been set up with an explicit exit point,
+    # as could be the case for a pure orange middleware stack on 
+    # top of a different exit application (like Sinatra or Rails)
+    def main_app
+      @main_app
+    end
+    
+    # Adds middleware using the Rack::Builder#use method
+    # @param [Object] middleware A class of middleware that meets rack middleware requirements
+    def use(middleware, *args, &block)
+      @build.use(middleware, *args, &block)
+    end
+    
+    # Loads resources into the core using the Orange::Core#load method
+    # 
+    # all args are passed on
+    def load(*args, &block)
+      orange.load(*args, &block)
+    end
+    
+    # Adds Orange-aware middleware using the Rack::Builder#use method, adding
+    # the orange core to the args passed on
+    def stack(middleware, *args, &block)
+      @build.use(middleware, @core, *args, &block)
+    end
+    
+    # Set the auto_reload option, called without args, defaults to true,
+    # other option is to set it to false
+    def auto_reload!(val = true)
+      @auto_reload = val
+    end
+    
+    # Shortcut for adding Orange::Middleware::ShowExceptions to the middleware
+    # stack
+    def use_exceptions
+      stack Orange::Middleware::ShowExceptions
+    end
+    
+    # Turn off recapture middleware, which is normally just on top of the exit
+    # point
+    # @see Orange::Middleware::Recapture
+    def no_recapture
+      @recapture = false
+    end
+    
+    # A shortcut for adding many of the routing middleware options
+    # simultaneously. Includes:
+    # * Orange::Middleware::Rerouter
+    # * Orange::Middleware::Static
+    # * Rack::AbstractFormat
+    # * Orange::Middleware::RouteSite
+    # * Orange::Middleware::RouteContext
+    # 
+    # All of these are passed the args hash to use as they will, except 
+    # for Rack::AbstractFormat
+    # 
+    def prerouting(*args)
+      opts = args.extract_options!
+      stack Orange::Middleware::Rerouter, opts
+      stack Orange::Middleware::Static, opts
+      use Rack::AbstractFormat unless opts[:no_abstract_format] 
+          # Must be used before non-destructive route altering done by Orange,
+          # since all orange stuff is non-destructive
+      stack Orange::Middleware::RouteSite, opts
+      stack Orange::Middleware::RouteContext, opts
+    end
+    
+    # A shortcut for enabling restful routing via Orange::Middleware::RestfulRouter
+    #
+    # Any args are passed on to the middleware
+    def restful_routing(*args)
+      opts = args.extract_options!
+      stack Orange::Middleware::RestfulRouter, opts
+    end
+    
+    # A shortcut to enable Rack::OpenID and Orange::Middleware::AccessControl
+    # 
+    # Args will be passed on to Orange::Middleware::AccessControl
+    # @todo Make it so this is not dependent on the openid_dm_store gem
+    def openid_access_control(*args)
+      opts = args.extract_options!
+      require 'rack/openid'
+      require 'openid_dm_store'
+
+      use Rack::OpenID, OpenIDDataMapper::DataMapperStore.new
+      stack Orange::Middleware::AccessControl, opts
+    end
+    
+    # Adds pulp to the core via the Orange::Core#add_pulp method
+    # @param [Orange::Mixin] mod a mixin to be included in the packet
+    def add_pulp(mod)
+      orange.add_pulp(mod)
+    end
+    
+    # The exit point for the middleware stack, 
+    # this method will add the Orange::Middleware::Recapture if applicable
+    # add the app to @main_app and then call Rack::Builder#run with the main app
+    def run(app, *args)
+      opts = args.extract_options!
+      if @recapture
+        stack Orange::Middleware::Recapture
+        @recapture = false
+      end
+      @main_app = app
+      @build.run(app)
+    end
+    
+    # Returns the Orange::Core
+    # @return [Orange::Core] The orange core 
+    def orange
+      @core
+    end
+
+    # Passes through to Rack::Builder#map
+    # @todo Make this work - passing the block on to builder 
+    #   means we can't intercept anything, which will yield 
+    #   unexpected results
+    def map(path, &block)
+      raise 'not yet supported'
+      @build.map(path, &block)
+    end
+    
+    # Builds the middleware stack (or uses a cached one)
+    # 
+    # If auto_reload is enabled ({#auto_reload!}), builds every time
+    #
+    # @return [Object] a full stack of middleware and the exit application,
+    #   conforming to Rack guidelines
+    def app
+      @app = false if @auto_reload      # Rebuild no matter what if autoload
+      @app ||= @build.to_app            # Build if necessary
+      orange.fire(:stack_loaded, @app)
+      @app
+    end
+    
+    # Sets the core and then passes on to the stack, according to standard 
+    # rack procedure
+    def call(env)
+      env['orange.core'] = @core
+      app.call(env)
+    end
+  end
+end