orange 0.5.5 → 0.5.7

data/lib/orange-core/assets/css/exceptions.css

@@ -1,50 +0,0 @@
-html * { padding:0; margin:0; }
-body * { padding:10px 20px; }
-body * * { padding:0; }
-body { font:small sans-serif; }
-body>div { border-bottom:1px solid #ddd; }
-h1 { font-weight:normal; }
-h2 { margin-bottom:.8em; }
-h2 span { font-size:80%; color:#666; font-weight:normal; }
-h3 { margin:1em 0 .5em 0; }
-h4 { margin:0 0 .5em 0; font-weight: normal; }
-table {
-    border:1px solid #ccc; border-collapse: collapse; background:white; }
-tbody td, tbody th { vertical-align:top; padding:2px 3px; }
-thead th {
-    padding:1px 6px 1px 3px; background:#fefefe; text-align:left;
-    font-weight:normal; font-size:11px; border:1px solid #ddd; }
-tbody th { text-align:right; color:#666; padding-right:.5em; }
-table.vars { margin:5px 0 2px 40px; }
-table.vars td, table.req td { font-family:monospace; }
-table td.code { width:100%;}
-table td.code div { overflow:hidden; }
-table.source th { color:#666; }
-table.source td {
-    font-family:monospace; white-space:pre; border-bottom:1px solid #eee; }
-ul.traceback { list-style-type:none; }
-ul.traceback li.frame { margin-bottom:1em; }
-div.context { margin: 10px 0; }
-div.context ol {
-    padding-left:30px; margin:0 10px; list-style-position: inside; }
-div.context ol li {
-    font-family:monospace; white-space:pre; color:#666; cursor:pointer; }
-div.context ol.context-line li { color:black; background-color:#ccc; }
-div.context ol.context-line li span { float: right; }
-div.commands { margin-left: 40px; }
-div.commands a { color:black; text-decoration:none; }
-#summary { background: #fda; }
-#summary h2 { font-weight: normal; color: #666; }
-#summary ul#quicklinks { list-style-type: none; margin-bottom: 2em; }
-#summary ul#quicklinks li { float: left; padding: 0 1em; }
-#summary ul#quicklinks>li+li { border-left: 1px #666 solid; }
-#explanation { background:#eee; }
-#template, #template-not-exist { background:#f6f6f6; }
-#template-not-exist ul { margin: 0 0 0 20px; }
-#traceback { background:#eee; }
-#requestinfo { background:#f6f6f6; padding-left:120px; }
-#summary table { border:none; background:transparent; }
-#requestinfo h2, #requestinfo h3 { position:relative; margin-left:-100px; }
-#requestinfo h3 { margin-bottom:-1em; }
-.error { background: #ffc; }
-.specific { color:#cc3300; font-weight:bold; }

data/lib/orange-core/assets/js/exceptions.js

@@ -1,44 +0,0 @@
-function getElementsByClassName(oElm, strTagName, strClassName){
-// Written by Jonathan Snook, http://www.snook.ca/jon;
-// Add-ons by Robert Nyman, http://www.robertnyman.com
-var arrElements = (strTagName == "*" && document.all)? document.all :
-oElm.getElementsByTagName(strTagName);
-var arrReturnElements = new Array();
-strClassName = strClassName.replace(/\-/g, "\\-");
-var oRegExp = new RegExp("(^|\\s)" + strClassName + "(\\s|$$)");
-var oElement;
-for(var i=0; i<arrElements.length; i++){
-    oElement = arrElements[i];
-    if(oRegExp.test(oElement.className)){
-        arrReturnElements.push(oElement);
-    }
-}
-return (arrReturnElements)
-}
-function hideAll(elems) {
-for (var e = 0; e < elems.length; e++) {
-elems[e].style.display = 'none';
-}
-}
-window.onload = function() {
-hideAll(getElementsByClassName(document, 'table', 'vars'));
-hideAll(getElementsByClassName(document, 'ol', 'pre-context'));
-hideAll(getElementsByClassName(document, 'ol', 'post-context'));
-}
-function toggle() {
-for (var i = 0; i < arguments.length; i++) {
-var e = document.getElementById(arguments[i]);
-if (e) {
-  e.style.display = e.style.display == 'none' ? 'block' : 'none';
-}
-}
-return false;
-}
-function varToggle(link, id) {
-toggle('v' + id);
-var s = link.getElementsByTagName('span')[0];
-var uarr = String.fromCharCode(0x25b6);
-var darr = String.fromCharCode(0x25bc);
-s.innerHTML = s.innerHTML == uarr ? darr : uarr;
-return false;
-}

data/lib/orange-core/carton.rb

@@ -1,178 +0,0 @@
-require 'dm-core'
-
-module Orange
-  # Orange::Carton is the main model class for Orange. It's based on Datamapper.
-  # In addition to handling the database interactions, the carton keeps
-  # track of declared properties, which is used to create scaffolds.
-  #
-  # All subclasses should start by declaring the "id" attribute. All models
-  # are assumed to have an id attribute by most everything else, so it's 
-  # a good idea to have one. Also, we use this to tie in initialization before
-  # using the other dsl-ish methods (since these other methods are class level
-  # and would happen before initialize ever gets called)
-  # 
-  # Orange::Carton adds many shortcut methods for adding various datatypes
-  # to the model in a more declarative style (`id` vs `property :id, Serial`)
-  # 
-  # For classes that don't need anything but scaffolding, there's the 
-  # as_resource method, which automatically creates a scaffolding resource
-  # for the model.
-  # 
-  # A model that doesn't need scaffolded at all could optionally forgo the carton
-  # class and just include DataMapper::Resource. All carton methods are to
-  # improve scaffolding capability.
-  class Carton
-    SCAFFOLD_OPTIONS = [:display_name, :levels] unless defined?(SCAFFOLD_OPTIONS)
-    extend ClassInheritableAttributes
-    cattr_accessor :scaffold_properties
-    
-    # Declares a ModelResource subclass that scaffolds this carton
-    # The Subclass will have the name of the carton followed by "_Resource"
-    def self.as_resource
-      name = self.to_s
-      eval <<-HEREDOC
-      class ::#{name}_Resource < Orange::ModelResource
-        use #{name}
-      end
-      HEREDOC
-    end
-    
-    # Include DataMapper types (required to be able to use Serial)
-    include DataMapper::Types
-    
-    # Do setup of object and declare an id
-    def self.id
-      include DataMapper::Resource
-      property(:id, Serial)
-      self.scaffold_properties ||= []
-      self.init
-    end
-    
-    # Stub init method
-    def self.init
-    end
-    
-    # Return properties that should be shown for a given context
-    def self.form_props(context = :live)
-      self.scaffold_properties.select{|p| p[:levels].include?(context)  }
-    end
-    
-    # Helper to wrap properties into admin level
-    def self.admin(&block)
-      @levels = [:admin, :orange]
-      instance_eval(&block)
-      @levels = false
-    end
-    
-    # Helper to wrap properties into orange level
-    def self.orange(&block)
-      @levels = [:orange]
-      instance_eval(&block)
-      @levels = false
-    end
-    
-    # Helper to wrap properties into front level
-    def self.front(&block)
-      @levels = [:live, :admin, :orange]
-      instance_eval(&block)
-      @levels = false
-    end
-    
-    def self.add_scaffold(name, type, dm_type, opts)
-      self.scaffold_properties << {:name => name, :type => type, :levels => @levels}.merge(opts) if @levels || opts.has_key?(:levels)
-      opts = opts.delete_if{|k,v| SCAFFOLD_OPTIONS.include?(k)} # DataMapper doesn't like arbitrary opts
-      self.property(name, dm_type, opts)
-    end
-    
-    # Define a helper for title type database stuff
-    # Show in a context if wrapped in one of the helpers
-    def self.title(name, opts = {})
-      add_scaffold(name, :title, String, opts)
-    end
-    
-    # Define a helper for title type database stuff
-    # Show in a context if wrapped in one of the helpers
-    def self.datetime(name, opts = {})
-      add_scaffold(name, :datetime, DateTime, opts)
-    end
-    
-    # Define a helper for title type database stuff
-    # Show in a context if wrapped in one of the helpers
-    def self.date(name, opts = {})
-      add_scaffold(name, :date, Date, opts)
-    end
-    
-    # Define a helper for title type database stuff
-    # Show in a context if wrapped in one of the helpers
-    def self.time(name, opts = {})
-      add_scaffold(name, :time, Time, opts)
-    end
-    
-    # Define a helper for fulltext type database stuff
-    # Show in a context if wrapped in one of the helpers
-    def self.fulltext(name, opts = {})
-      add_scaffold(name, :fulltext, Text, opts)
-    end
-    
-    # Define a helper for boolean type database stuff
-    # Show in a context if wrapped in one of the helpers
-    def self.boolean(name, opts = {})
-      add_scaffold(name, :boolean, Boolean, opts)
-    end
-    
-    # Define a helper for input type="text" type database stuff
-    # Show in a context if wrapped in one of the helpers
-    def self.text(name, opts = {})
-      add_scaffold(name, :text, String, opts)
-    end
-    
-    # Define a helper for type database stuff
-    # Show in a context if wrapped in one of the helpers
-    def self.expose(name, opts = {})
-      self.scaffold_properties << {:name => name, :type => :text, :levels => @levels, :opts => opts} if @levels
-    end
-    
-    # Define a helper for input type="text" type database stuff
-    # Show in a context if wrapped in one of the helpers
-    def self.string(name, opts = {})
-      self.text(name, opts)
-    end
-    
-    # Override DataMapper to include context sensitivity (as set by helpers)
-    def self.scaffold_property(name, type, opts = {})
-      my_type = type.to_s.downcase.to_sym
-      add_scaffold(name, my_type, type, opts)
-    end
-      
-    
-    # For more generic cases, use same syntax as DataMapper does.
-    # The difference is that this will make it an admin property.
-    def self.admin_property(name, type, opts = {})
-      my_type = type.to_s.downcase.to_sym
-      opts[:levels] = [:admin, :orange]
-      add_scaffold(name, my_type, type, opts)
-    end
-    
-    # For more generic cases, use same syntax as DataMapper does.
-    # The difference is that this will make it a front property.
-    def self.front_property(name, type, opts = {})
-      my_type = type.to_s.downcase.to_sym
-      opts[:levels] = [:live, :admin, :orange]
-      add_scaffold(name, my_type, type, opts)
-    end
-    
-    # For more generic cases, use same syntax as DataMapper does.
-    # The difference is that this will make it an orange property.
-    def self.orange_property(name, type, opts = {})
-      my_type = type.to_s.downcase.to_sym
-      opts[:levels] = [:orange]
-      add_scaffold(name, my_type, type, opts)
-    end
-    
-    def to_s
-      <<-DOC
-      {"class": "#{self.class.to_s}", "id": "#{self.id}"}
-      DOC
-    end
-  end
-end

data/lib/orange-core/core.rb

@@ -1,266 +0,0 @@
-require 'dm-core'
-require 'rack'
-require 'rack/builder'
-
-module Orange
-  # Declare submodules for later use
-  module Pulp; end
-  module Mixins; end
-  module Plugins; end
-  
-  attr_accessor :plugins
-  
-  # Support for plugins
-  def self.plugins
-    @plugins ||= []
-  end
-  
-  # Allows adding plugins
-  def self.plugin(plugin)
-    self.plugins << plugin if plugin.kind_of?(Orange::Plugins::Base)
-  end
-  
-  # Allow mixins directly from Orange
-  def self.mixin(inc)
-    Core.mixin inc
-  end
-  
-  # Allow pulp directly from Orange
-  def self.add_pulp(inc)
-    Packet.mixin inc
-  end
-  
-  # Core is one of two main sources of interaction for Orange Applications
-  # 
-  # All portions of Orange based code have access to the Core upon
-  # initialization. Orange allows access to individual resources, 
-  # and also allows single point for event registration and firing.
-  # 
-  # Functionality of the core can be extended by loading resources,
-  # or by mixins that directly affect the Core. Generally, resources
-  # are the less convoluted (easier to debug) way to do it.
-  class Core
-    # Sets the default options for Orange Applications
-    DEFAULT_CORE_OPTIONS = 
-      {
-        :contexts => [:live, :admin, :orange],
-        :default_context => :live,
-        :default_resource => :not_found,
-        :default_database => 'sqlite3::memory:'
-      } unless defined?(DEFAULT_CORE_OPTIONS)
-    
-    # Args will be set to the @options array. 
-    # Block DSL style option setting also available:
-    #
-    #   orange = Orange::Core.new(:optional_option => 'foo') do
-    #     haml true
-    #     site_name "Banana"
-    #     custom_router MyRouterClass.new
-    #   end
-    #
-    #   orange.options[:site_name] #=> "Banana"
-    # 
-    # This method calls afterLoad when it is done. Subclasses can override
-    # the afterLoad method for initialization needs.
-    def initialize(*args, &block)
-      @options = Options.new(*args, &block).hash.with_defaults(DEFAULT_CORE_OPTIONS)
-      @resources = {}
-      @application = false
-      @stack = false
-      @middleware = []
-      @events = {}
-      @file = __FILE__
-      load(Orange::Parser.new, :parser)
-      load(Orange::Mapper.new, :mapper)
-      load(Orange::Scaffold.new, :scaffold)
-      load(Orange::PageParts.new, :page_parts)
-      Orange.plugins.each{|p| p.resources.each{|args| load(*args)} if p.has_resources?}
-      self.register(:stack_loaded) do |s| 
-        @middleware.each{|m| m.stack_init if m.respond_to?(:stack_init)}
-        @application.stack_init if @application
-      end
-      self.register(:stack_reloading){|s| @middleware = []} # Dump middleware on stack reload
-      # load(Orange::AdminResource.new, :admin)
-      afterLoad
-      self
-    end
-    
-    # Returns the orange library directory
-    # @return [String] the directory name indicating where the core file is
-    #   located
-    def core_dir(*args)
-      if args
-        File.join((options[:core_dir] ||= File.dirname(__FILE__)), *args)
-      else
-        options[:core_dir] ||= File.dirname(__FILE__)
-      end
-    end
-    
-    # Returns the directory of the currently executing file (using Dir.pwd),
-    # can be overriden using the option :app_dir in initialization
-    # 
-    # @return [String] the directory name of the currently running application
-    def app_dir(*args)
-      if args
-        File.join((options[:app_dir] ||= Dir.pwd), *args)
-      else
-        options[:app_dir] ||= Dir.pwd
-      end
-    end
-    
-    # Called by initialize after finished loading
-    def afterLoad
-      true
-    end
-    
-    # Returns status of a given resource by short name
-    # @param [Symbol] resource_name The short name of the resource
-    # @return [Boolean] result of has_key? in the resources list
-    def loaded?(resource_name)
-      @resources.has_key?(resource_name)
-    end
-    
-    # Takes an instance of a Orange::Resource subclass, sets orange
-    # then adds it to the orange resources
-    # 
-    # It can be assigned a short name to be used for accessing later
-    # on. If no short name is assigned, one will be generated by downcasing
-    # the class name and changing it to a symbol
-    #
-    # Resources must respond to set_orange, which is automatically used to 
-    # create a link back to the Core, and to notify the resource of its assigned
-    # short name.
-    # 
-    # @param [Orange::Resource] resource An instance of Orange::Resource subclass
-    # @param [optional, Symbol, String] name A short name to assign as key in Hash 
-    #   list of resources.
-    #   Doesn't necessarily need to be a symbol, but generally is.
-    #   Set to the class name lowercase as a symbol by default.
-    def load(resource, name = false)
-      name = resource.orange_name if(!name)
-      name = resource.class.to_s.gsub(/::/, '_').downcase.to_sym if(!name) 
-      @resources[name] = resource.set_orange(self, name)
-    end
-    
-    # Takes an instance of Orange::Middleware::Base subclass and
-    # keeps it for later. This way we can provide introspection into the 
-    # middleware instances (useful for calling stack_init on them)
-    def middleware(middle = false)
-      @middleware << middle if middle
-      @middleware
-    end
-    
-    # Takes an instance of Orange::Application and saves it. 
-    def application(app = false)
-      @application = app if app
-      @application
-    end
-    
-    # Takes an instance of Orange::Stack and saves it. 
-    def stack(new_stack = false)
-      @stack = new_stack if new_stack
-      @stack
-    end
-    
-    # Takes an instance of Orange::Stack and saves it.
-    def stack=(new_stack)
-      @stack = new_stack
-    end
-    
-    # Convenience self for consistent naming across middleware
-    # @return [Orange::Core] self
-    def orange;     self;     end
-    
-    # Registers interest in a callback for a named event.
-    #
-    # Event registration is stored as a hash list of events and arrays
-    # of procs to be executed on each event.
-    #
-    # @param [Symbol] event the name of the event registered for 
-    # @param [optional, Integer] position the position to place the event in,
-    #  by default goes to the front of the list. Doesn't necessarily need
-    #  to be exact count, empty spaces in array are taken out. Forcing the
-    #  event to be at 99 or some such position will typically make sure it 
-    #  happens last in the firing process.
-    # @param [Block] block The code to be executed upon event firing. 
-    #   Saved to an array of procs that are called when #fire is called.
-    #   Block must accept one param, which is the intended to be the packet 
-    #   causing the block to fire, unless the event happens in setup.
-    def register(event, position = 0, &block)
-      if block_given?
-        if @events[event] 
-          @events[event].insert(position, Proc.new)
-        else
-          @events[event] = Array.new.insert(position, Proc.new)
-        end
-      end
-    end
-    
-    # Fires a callback for a given packet (or other object)
-    # 
-    # @param [Symbol] event name of event something has registered for
-    # @param [Orange::Packet, object] packet Object, generally Orange::Packet, 
-    #   causing the fire. This is passed to each Proc registered.
-    # @return [Boolean] returns false if nothing has been registered for the
-    #   event, otherwise true.
-    def fire(event, packet, *args)
-      return false unless @events[event]
-      @events[event].compact!
-      for callback in @events[event]
-        callback.call(packet, *args)
-      end
-      true
-    end
-    
-    # Returns options of the orange core
-    # 
-    # @return [Hash] Hash of options
-    def options
-      @options
-    end
-    
-    
-    # Accesses resources array, stored as a hash {:short_name => Resource instance,...}
-    # 
-    # @param [Symbol] name the short name for the requested resource
-    # @param [optional, Boolean] ignore Whether to ignore any calls to resource if not found 
-    #   (false is default). This will allow method calls to non-existent resources. Should be
-    #   used with caution.
-    # @return [Orange::Resource] the resource for the given short name
-    def [](name, ignore = false)
-      if ignore && !loaded?(name)
-        Ignore.new
-      else
-        @resources[name]
-      end 
-    end
-    
-    # Includes module in the Packet class
-    # @param [Module] inc module to be included
-    def add_pulp(inc)
-      self.class.add_pulp inc
-    end
-    
-    # Includes module in this class
-    # @param [Module] inc module to be included
-    def mixin(inc)
-      self.class.mixin inc
-    end
-    
-    # Includes module in this class
-    # @param [Module] inc module to be included
-    def self.mixin(inc)
-      include inc
-    end
-    
-    # Includes module in the Packet class
-    # @param [Module] inc module to be included
-    def self.add_pulp(inc)
-      Packet.mixin inc
-    end
-    
-    def inspect
-      "#<Orange::Core:0x#{self.object_id.to_s(16)}>"
-    end
-  end
-end