orange 0.0.2

data/lib/orange/middleware/show_exceptions.rb

@@ -0,0 +1,78 @@
+require 'ostruct'
+require 'rack/request'
+require 'rack/utils'
+require 'orange/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.
+
+  class ShowExceptions < Base
+    CONTEXT = 7
+
+    def call(env)
+      @app.call(env)
+    rescue StandardError, LoadError, SyntaxError => 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/middleware/site_load.rb

@@ -0,0 +1,33 @@
+require 'orange/middleware/base'
+module Orange::Middleware
+  # This will load information about the site to into the orange env
+  # - packet['site'] will be an instance of the site object
+  # 
+  class SiteLoad < Base
+    def init(*args)
+      orange.load Orange::SiteResource.new, :orange_sites
+    end
+    
+    def packet_call(packet)
+      url =  packet['route.site_url']
+      site = Orange::Site.first(:url.like => url)
+      packet['site'] = site if site
+      pass packet
+    end
+  end
+  
+end
+
+module Orange
+  class Site < Carton
+    id
+    admin do
+      title :name
+      text :url
+    end
+  end
+  
+  class SiteResource < ModelResource
+    use Orange::Site
+  end
+end

data/lib/orange/middleware/static.rb

@@ -0,0 +1,81 @@
+require 'orange/middleware/base'
+require 'orange/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={})
+      core.mixin Orange::Mixins::Static
+      core.add_static('_orange_', File.join(core.core_dir, 'assets'))
+      @app = app
+      @core = core
+      @libs = options[:libs] || [Orange::Core]
+      
+      @urls = options[:urls] || ["/favicon.ico", "/assets/public"]
+      @root = options[:root] || File.join(orange.app_dir, 'assets')
+      @lib_urls = core.statics
+
+      @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(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
+        @file_server.call(packet.env)
+      else
+        pass packet
+      end
+    end
+
+  end
+end
+
+module Orange::Mixins::Static
+  def add_static(lib_name, path)
+    @statics ||= {}
+    key = File.join('', 'assets', lib_name)
+    @statics.merge!(key => path)
+  end
+  
+  def statics
+    @statics ||= {}
+  end
+end

data/lib/orange/middleware/static_file.rb

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

data/lib/orange/middleware/template.rb

@@ -0,0 +1,61 @@
+require 'orange/core'
+require 'orange/middleware/base'
+
+module Orange::Middleware
+  
+  class Template < Base
+    def init(*args)
+      @core.add_pulp(Orange::Pulp::Template)
+      @core.mixin(Orange::Mixins::Template)
+      
+      # Establish a default template chooser
+      @core.template_chooser do |packet|
+        if packet['route.context'] == :admin
+          packet.add_css('admin.css', :module => '_orange_')
+          'admin.haml'
+        else
+          false
+        end
+      end
+    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)
+      end
+      [status, headers, content]
+    end
+    
+    def needs_wrapped?(packet)
+      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)
+    @template_chooser = Proc.new
+  end
+end

data/lib/orange/model_resource.rb

@@ -0,0 +1,170 @@
+require 'orange/routable_resource'
+
+module Orange
+  class ModelResource < RoutableResource
+    extend ClassInheritableAttributes
+    cattr_inheritable :model_class
+    
+    def self.use(my_model_class)
+      @model_class = my_model_class
+    end
+    
+    
+    def model_class
+      self.class.model_class
+    end
+    
+    def view(packet, *args)
+      opts = args.extract_options!.with_defaults({:path => ''})
+      props = model_class.form_props(packet['route.context'])
+      resource_id = opts[:id] || packet['route.resource_id'] || false
+      mode = opts[:mode] || packet['route.resource_action'] || 
+        (resource_id ? :show : :list)  
+      
+      haml_opts = {:props => props, :resource => self.class.to_s, :model_name => @my_orange_name}.merge!(opts)
+      
+      case mode
+      when :show
+        haml_opts.with_defaults! :model => findOne(packet, mode, resource_id)
+        orange[:parser].haml('show.haml', packet, haml_opts)
+      when :edit
+        haml_opts.with_defaults! :model => findOne(packet, mode, resource_id)
+        orange[:parser].haml('edit.haml', packet, haml_opts)
+      when :create
+        haml_opts.with_defaults! :model => findOne(packet, mode, resource_id)
+        orange[:parser].haml('create.haml', packet, haml_opts)
+      when :table_row
+        haml_opts.with_defaults! :model => findOne(packet, mode, resource_id)
+        orange[:parser].haml('table_row.haml', packet, haml_opts)
+      when :list
+        haml_opts.with_defaults! :list => findList(packet, mode)
+        orange[:parser].haml('list.haml', packet, haml_opts)
+      else
+        self.__send__(mode, packet, haml_opts)
+      end
+    end
+    
+    def findOne(packet, mode, id = false)
+      return false unless id
+      model_class.get(id) 
+    end
+    
+    def findList(packet, mode)
+      model_class.all || []
+    end
+    
+    def viewExtras(packet, mode)
+      {}
+    end
+    
+    def route(path, packet)
+      parts = path.split('/')
+      if parts[0] =~ /^[0-9]+$/
+        route_id = parts.shift 
+      else 
+        route_id = false
+      end
+      parts.unshift('show') if parts.empty? && route_id
+      new_path = parts.join('/')
+      packet['route.resource_id'] = route_id if route_id
+      super(new_path, packet)
+    end
+    
+    def new(packet, *opts)
+      if packet.request.post?
+        model_class.new(packet.request.params[@my_orange_name.to_s]).save
+      end
+      packet.reroute(@my_orange_name, :orange)
+    end
+    
+    def delete(packet, *opts)
+      if packet.request.delete?
+        m = model_class.get(packet['route.resource_id'])
+        m.destroy! if m
+      end
+      packet.reroute(@my_orange_name, :orange)
+    end
+    
+    def save(packet, *opts)
+      if packet.request.post?
+        m = model_class.get(packet['route.resource_id'])
+        if m
+          m.update(packet.request.params[@my_orange_name.to_s])
+        else 
+        end
+      end
+      packet.reroute(@my_orange_name, :orange)
+    end
+    
+    
+    def show(packet, *opts)
+      view(packet, :mode => :show, *opts)
+    end
+    
+    def edit(packet, *opts)
+      view(packet, :mode => :edit, *opts)
+    end
+    
+    def create(packet, *opts)
+      view(packet, :mode => :create, *opts)
+    end
+    
+    def table_row(packet, *opts)
+      view(packet, :mode => :table_row, *opts)
+    end
+    
+    def list(packet, *opts)
+      view(packet, :mode => :list, *opts)
+    end
+    
+    def index(packet, *opts)
+      view(packet, :mode => :list, *opts)
+    end
+  
+  end
+  
+  class Packet
+    def form_link(text, link, confirm = false, *args)
+      opts = args.extract_options!
+      meth = (opts[:method]? "<input type='hidden' name='_method' value='#{opts[:method]}' />" : '')
+      if confirm
+        "<form action='#{link}' method='post' class='mini' onsubmit='return confirm(\"#{confirm}\")'><button class='link_button'><a href='#'>#{text}</a></button>#{meth}</form>"
+      else
+        "<form action='#{link}' method='post' class='mini'><button class='link_button'><a href='#'>#{text}</a></button>#{meth}</form>"
+      end
+    end
+    
+    def view(model_name, *args)
+      orange[model_name].view(self, *args)
+    end
+    
+    def view_attribute(prop, model_name, *args)
+      args = args.extract_options!
+      val = args[:value] || ''
+      label = args[:label] || false
+      show = args[:show] || false
+      name = prop[:name]
+      if !show
+        case prop[:type]
+        when :title
+          ret = "<input class='title' type='text' value='#{val}' name='#{model_name}[#{name}]' />"
+        when :text
+          ret = "<input type='text' value='#{val}' name='#{model_name}[#{name}]' />"
+        when :fulltext
+          ret = "<textarea name='#{model_name}[#{name}]'>#{val}</textarea>"
+        end
+        ret = "<label for=''>#{name}</label><br />" + ret if label
+      else
+        case prop[:type]
+        when :title
+          ret = "<h3 class='#{model_name}-#{name}'>#{val}</h3>"
+        when :text
+          ret = "<p class='#{model_name}-#{name}'>#{val}</p>"
+        when :fulltext
+          ret = "<div class='#{model_name}-#{name}'>#{val}</div>"
+        end
+      end
+      ret
+    end
+  end
+end