orange 0.5.5 → 0.5.7

data/lib/orange-core/resources/routable_resource.rb

@@ -1,16 +0,0 @@
-require 'orange-core/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-core/resources/scaffold.rb

@@ -1,106 +0,0 @@
-require 'orange-core/core'
-
-module Orange
-  class Scaffold < Resource
-    # Load the scaffold helpers
-    def afterLoad
-      orange.add_pulp Pulp::ScaffoldHelpers
-      Packet.meta_methods(/view_([a-zA-Z_]+)/) do |packet, match, args|
-        model = args.shift
-        args = args.extract_with_defaults(:mode => match[1].to_sym)
-        packet.view(model, args)
-      end
-      @scaffold_types = {}
-      add_scaffold_type(:boolean) do |name, val, opts|
-        if opts[:show]
-          val ? "true" : "false"
-        else
-          ret = "<input type='hidden' name='#{opts[:model_name]}[#{name}]' value='0' /><input type='checkbox' name='#{opts[:model_name]}[#{name}]' value='1' #{'checked="checked"' if (val && val != '')}/>"
-          ret = "<label for=''>#{opts[:display_name]}</label><br />" + ret if opts[:label]
-        end
-      end
-    end
-    
-    def add_scaffold_type(type, &block)
-      @scaffold_types[type] = Proc.new
-    end
-    
-    def scaffold_attribute(packet, prop, model_name, *args)
-      args = args.extract_options!
-      args.with_defaults!({:packet => packet, :value => '', :label => false, :show => false})
-      val = args[:value]
-      label = args[:label]
-      show = args[:show]
-      name = prop[:name]
-      human_readable_name = name.to_s.split('_').each{|w| w.capitalize!}.join(' ')
-      display_name = prop[:display_name] || human_readable_name
-      return @scaffold_types[prop[:type]].call(name, val, args.with_defaults!(:display_name => display_name, :model_name => model_name)) if @scaffold_types.has_key?(prop[:type])
-      unless show
-        case prop[:type]
-        when :title
-          val.gsub!('"', '&quot;')
-          ret = "<input class=\"title\" type=\"text\" value=\"#{val}\" name=\"#{model_name}[#{name}]\" />"
-        when :text
-          val.gsub!('"', '&quot;')
-          ret = "<input type=\"text\" value=\"#{val}\" name=\"#{model_name}[#{name}]\" />"
-        when :fulltext
-          ret = "<textarea name='#{model_name}[#{name}]'>#{val}</textarea>"
-        when :boolean
-          human_readable_name = human_readable_name + '?'
-          ret = "<input type='hidden' name='#{model_name}[#{name}]' value='0' /><input type='checkbox' name='#{model_name}[#{name}]' value='1' #{'checked="checked"' if (val && val != '')}/>"
-        when :date
-          val.gsub!('"', '&quot;')
-          ret = "<input class=\"date\" type=\"text\" value=\"#{val}\" name=\"#{model_name}[#{name}]\" />"
-        else
-          val.gsub!('"', '&quot;')
-          ret = "<input type=\"text\" value=\"#{val}\" name=\"#{model_name}[#{name}]\" />"
-        end
-        ret = "<label for=''>#{display_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>"
-        else
-          ret = "<div class='#{model_name}-#{name}'>#{val}</div>"
-        end
-      end
-      return ret
-    end
-  end
-  
-  module Pulp::ScaffoldHelpers
-    # Creates a button that appears to be a link but 
-    # does form submission with custom method (_method param in POST)
-    # This is to avoid issues of a destructive get.
-    # @param [String] text link text to show
-    # @param [String] link the actual href value of the link
-    # @param [String, false] confirm text of the javascript confirm (false for none [default])
-    # @param [optional, Array] args array of optional arguments, only opts[:method] defined
-    # @option opts [String] method method name (Should be 'DELETE', 'PUT' or 'POST')
-    def form_link(text, link, confirm = false, opts = {})
-      text = "<img src='#{opts[:img]}' alt='#{text}' />" if opts[:img]
-      css = opts[:class]? opts[:class] : 'form_button_link'
-      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='#' class='#{css}'>#{text}</a></button>#{meth}</form>"
-      else
-        "<form action='#{link}' method='post' class='mini'><button class='link_button'><a href='#' class='#{css}'>#{text}</a></button>#{meth}</form>"
-      end
-    end
-    
-    # Calls view for an orange resource. 
-    def view(model_name, *args)
-      orange[model_name].view(self, *args)
-    end
-    
-    # Returns a scaffolded attribute
-    def view_attribute(prop, model_name, *args)
-      orange[:scaffold].scaffold_attribute(self, prop, model_name, *args)
-    end
-  end
-  
-end

data/lib/orange-core/stack.rb

@@ -1,226 +0,0 @@
-require 'orange-core/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 [Orange::Core] core the orange core
-    # @param [Symbol] prebuilt the optional prebuilt stack, if one isn't passed as block
-    def initialize(app_class = nil, core = false, prebuilt = :none, &block)
-      @build = Rack::Builder.new
-      @core = core || Orange::Core.new
-      @core.stack = self # Set a back reference in the core.
-      @auto_reload = false
-      @app = false
-      @middleware = []
-      @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
-        run @main_app
-      else
-        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
-    
-    # Alias for use_exceptions
-    def show_exceptions
-      use_exceptions
-    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::Globals
-      stack Orange::Middleware::Loader
-      stack Orange::Middleware::Rerouter, opts.dup
-      stack Orange::Middleware::Static, opts.dup
-      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.dup
-      stack Orange::Middleware::RouteContext, opts.dup
-      stack Orange::Middleware::Database
-      Orange.plugins.each{|p| p.middleware(:prerouting).each{|m| stack m, opts.dup} if p.has_middleware?}
-    end
-    
-    # A shortcut for routing via Orange::Middleware::RestfulRouter and any plugins
-    #
-    # Any args are passed on to the middleware
-    def routing(opts ={})
-      stack Orange::Middleware::RestfulRouter, opts.dup
-      Orange.plugins.each{|p| p.middleware(:routing).each{|m| stack m, opts.dup} if p.has_middleware?}
-    end
-    
-    def postrouting(opts ={})
-      Orange.plugins.each{|p| p.middleware(:postrouting).each{|m| stack m, opts.dup} if p.has_middleware?}
-      stack Orange::Middleware::Template
-      stack Orange::Middleware::FourOhFour, opts.dup # Last ditch, send route to 404 page.
-    end
-    
-    def responders(opts ={})
-      Orange.plugins.each{|p| p.middleware(:responders).each{|m| stack m, opts.dup} if p.has_middleware?}
-    end
-    
-    # # A shortcut to enable Rack::OpenID and Orange::Middleware::AccessControl
-    #     # 
-    #     # Args will be passed on to Orange::Middleware::AccessControl
-    #     def openid_access_control(*args)
-    #       opts = args.extract_options!
-    #       
-    #     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,
-    # add the app to @main_app and then call Rack::Builder#run with the main app
-    def run(app, *args)
-      opts = args.extract_options!
-      @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
-      if @auto_reload
-        orange.fire(:stack_reloading, @app) if orange.stack  # Alert we are rebuilding
-        @app = false                    # Rebuild no matter what if autoload
-      end
-      unless @app 
-        @app = do_build            # Build if necessary
-        orange.fire(:stack_loaded, @app)
-      end
-      @app
-    end
-    
-    def do_build
-      @build.to_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
-    
-    # Debug helping
-    def inspect
-      "#<Orange::Stack:0x#{self.object_id.to_s(16)} @build=#{@build.inspect}, @core=#{@core.inspect}>"
-    end
-  end
-end

data/lib/orange-core/templates/exceptions.haml

@@ -1,111 +0,0 @@
--# adapted from Django <djangoproject.com>
--# Copyright (c) 2005, the Lawrence Journal-World
--# Used under the modified BSD license:
--# http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5
-!!! 
-%html
-  %head
-    %meta{:name=>"robots", :content=>"NONE,NOARCHIVE"}
-    %title Orange raised #{h exception.class} at #{h path}
-    %link{:rel=>"stylesheet", :href=>"/assets/_orange_/css/exceptions.css", :type=>"text/css"}
-    %script{:type=>"text/javascript", :src=>"/assets/_orange_/js/exceptions.js"}
-  %body
-    #summary
-      %h1 #{h exception.class} at #{h path}
-      %h2 #{h exception.message}
-      %table
-        %tr
-          %th Ruby
-          %td= "<code>#{h frames.first.filename}</code>: in <code>#{h frames.first.function}</code>, line #{h frames.first.lineno }"
-        %tr
-          %th Web
-          %td= "<code>#{h req.request_method} #{h(req.host + path)}</code>"
-      %h3= "Jump to:"
-      %ul#quicklinks
-        %li
-          %a{:href=>"#get-info"} GET
-        %li
-          %a{:href=>"#post-info"} POST
-        %li
-          %a{:href=>"#cookie-info"} Cookies
-        %li
-          %a{:href=>"#env-info"} ENV
-        %li
-          %a{:href=>"#orange-info"} Orange
-    #traceback
-      %h2= "Traceback <span>(innermost first)</span>"
-      %ul.traceback
-        - frames.each do |frame|
-          %li.frame
-            = "<code>#{h frame.filename}</code>: in <code>#{h frame.function}</code>"
-            - if frame.context_line
-              .context{:id => "c#{frame.object_id}"}
-                - if frame.pre_context
-                  %ol.pre-context{:start=>"#{h frame.pre_context_lineno+1}", :id=>"pre#{h frame.object_id }"}
-                    - frame.pre_context.each do |line|
-                      %li{:onclick=>"toggle('pre#{h frame.object_id}', 'post#{h frame.object_id }')"} #{h line}
-                %ol.context-line{:start=>"#{h frame.lineno}"}
-                  %li{ :onclick=>"toggle('pre#{h frame.object_id}', 'post#{h frame.object_id }')"}= "#{h frame.context_line} <span>...</span>"
-                - if frame.post_context
-                  %ol.post-context{ :start=>"#{h frame.lineno+1 }", :id=>"post#{h frame.object_id}"}
-                    - frame.post_context.each do |line|
-                      %li{:onclick=>"toggle('pre#{h frame.object_id}', 'post#{h frame.object_id }')"} #{h line}
-    #requestinfo
-      %h2 Request information
-      - for var in [:GET, :POST, :cookies]
-        %h3{:id => "#{var.to_s.downcase}-info"}= "#{var.to_s}"
-        - unless req.__send__(var).empty?
-          %table.req
-            %thead
-              %tr
-                %th Variable
-                %th Value
-            %tbody
-              - req.__send__(var).sort_by { |k, v| k.to_s }.each do |key, val|
-                %tr
-                  %td #{h key}
-                  %td.code
-                    %div #{h val.inspect}
-        - else
-          %p No #{var.to_s} data.
-      %h3#env-info Rack ENV
-      %table.req
-        %thead
-          %tr
-            %th Variable
-            %th Value
-        %tbody
-          - env.sort_by { |k, v| k.to_s }.each do |key, val|
-            - unless key =~ /^orange\./ 
-              %tr
-                %td #{h key}
-                %td.code
-                  %div #{h val}
-      %h3#orange-info Orange ENV
-      %table.req
-        %thead
-          %tr
-            %th Variable
-            %th Value
-        %tbody
-          - env['orange.env'].sort_by { |k, v| k.to_s }.each do |key, val|
-            - if(![:request, :headers, :content].include?(key)) 
-              %tr
-                %td #{h key}
-                %td.code
-                  %div #{h val}
-      %h3#orange-info= 'Orange<br /> Response'
-      %table.req
-        %thead
-          %tr
-            %th Variable
-            %th Value
-        %tbody
-          - env['orange.env'].sort_by { |k, v| k.to_s }.each do |key, val|
-            - if([:request, :headers, :content].include?(key)) 
-              %tr
-                %td #{h key}
-                %td.code
-                  %div #{h val}
-    #explanation
-      %p= "You're seeing this error because you use <code>Orange::Middleware::ShowExceptions</code>."