orange-core 0.5.3

data/README.markdown

@@ -0,0 +1,145 @@
+Orange
+======
+
+Orange is intended to be a middle ground between the simplicity of Sinatra 
+and the power of Rails. Orange is being developed by Orange Sparkle Ball, inc
+for our own use. 
+
+orange-core represents the core dependencies for orange applications. If you want
+a full featured Orange-based CMS, we're working on splitting that into the Sparkles
+project.
+
+**Note**: Orange is still in the alpha stage. Test coverage is lack-luster at best. 
+Tread carefully.
+
+More Info
+=========
+
+Orange Philosophy
+-----------------
+The Orange application framework is intended to be a fully customizable CMS
+capable of hosting sites while maintaining Sinatra-like ease of 
+programming. Some core ideas behind Orange:
+
+* We believe in magic - as long as it's not the evil kind
+* Put as much functionality into middleware as possible, so it can be easily reused
+  and remixed
+* Give middleware a little more power so it's useful enough to handle more tasks
+
+
+Should I Use Orange?
+--------------------
+
+    "I want to create a quick RESTful web service that does one thing and does it well"
+
+No. Use Sinatra for this kind of thing. It's perfect for creating quick web apps based on RESTful
+ideals. Or perhaps use a Sinatra clone built on Orange, so you can incorporate orange plugins... 
+but such a clone doesn't exist (yet).
+
+    "I want to create a powerful web application that needs to be rock solid and use a 
+    well-tested foundation"
+
+No. This is where Ruby on Rails shines, it's a well supported, thoroughly tested framework
+for building web applications that gives you everything you need for the lifecycle of your
+application
+
+    "I want to deploy a website on Ruby that has some dynamic elements, maybe allowing me
+    to create parts of the page in a plugin if necessary."
+    
+Yes. This is what orange was designed for - we're building it to be able to quickly deploy
+websites that can have a Ruby base without the heavy-weight Ruby on Rails backend, but without
+feeling like you have to start from scratch like it feels in Sinatra.
+
+
+Required Gems
+-------------
+
+To be updated... (this is full list for orange-core and orange-more, we're looking to minimize 
+orange-core dependencies).
+
+* dm-core (+ do_[sqlite3|mysql|...] )
+* dm-more
+* dm-is-awesome_set
+* rack
+* haml
+* rack-abstract-format (github)
+* ruby-openid
+* rack-openid
+* openid_dm_store
+* radius
+* crack
+* eventbright
+* spreedly
+* hominid
+* mail
+* tlsmail (If Ruby version <= 1.8.6)
+* gattica
+
+All dependencies should be loaded if you install the gem except for the datamapper
+adapter relevant to your set up. If, for example, you want to use a mysql database,
+you'll need to install do_mysql, and for an sqlite3 database, you'll need do_sqlite3
+
+
+Also, you'll need a web server of some kind and need to set it up for rack.
+
+**Testing** 
+
+If you want to test, you'll need the following gems:
+
+* rspec
+* rack-test
+
+Yard is also helpful for generating API docs
+
+The following are useful rake tasks for testing purposes:
+
+    * rake test   =>  (same as rake spec)
+    * rake spec   =>  runs rspec with color enabled and spec_helper included
+    * rake doc    =>  runs yardoc (no, not really necessary)
+    * rake clean  =>  clear out the temporary files not included in the repo
+    * rake rcov   =>  runs rspec with rcov
+
+For my own reference - jeweler rake task for deploying the new gem:
+
+    * rake version:bump:patch release
+    
+Programming Info
+================
+
+The basics of using the orange framework...
+
+Terminology
+-----------
+
+* **Application**: The last stop for the packet after traversing through the middleware stack.
+* **Core**: This is the core orange object, accessible from all points of the orange 
+  system. Usually the orange instance can be called by simply using the "orange" function
+* **Mixins**: Extra functionality added directly to the core. Mixins are generally for only
+  a couple of extra methods, anything more should probably be created as a resource.
+* **Packet**: This object represents a web request coming in to the orange system. 
+  Each request is instantiated as a packet before it is sent through the middleware stack.
+* **Pulp**: Mixin added to the packet object rather than the Core.
+* **Resources**: Resources are extra functionality contained within an object, accessible
+  from the core. 
+* **Stack**: The bundled collection of Orange-enhanced middleware sitting on top of the 
+  Orange application
+
+Pulp and Mixins
+---------------
+The ability to add pulp and mixins is incredibly handy because the packet and the core are 
+available from just about anywhere in the Orange framework. For instance, the haml parser
+evaluates all local calls as if made to the packet, so adding pulp is essentially adding 
+functionality that is directly available to haml.
+
+
+LICENSE:
+=========
+(The MIT License)
+
+Copyright © 2009 Orange Sparkle Ball, inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ‘Software’), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/orange-core.rb

@@ -0,0 +1,8 @@
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+require File.join(libdir, 'orange-core', 'magick.rb')
+Dir.glob(File.join(libdir, 'orange-core', '*.rb')).each {|f| require f }
+Dir.glob(File.join(libdir, 'orange-core', 'cartons', '*.rb')).each {|f| require f }
+Dir.glob(File.join(libdir, 'orange-core', 'resources', '*.rb')).each {|f| require f }
+Dir.glob(File.join(libdir, 'orange-core', 'middleware', '*.rb')).each {|f| require f }

data/lib/orange-core/application.rb

@@ -0,0 +1,132 @@
+module Orange
+  # Orange::Application is the main class used for building an
+  # Orange App. Typically you will not initialize it directly,
+  # but use the app method, which returns the entire Orange
+  # stack, with all middleware and the Orange::Application as
+  # the main receiver
+  #
+  # To override the stack generated by default, you can use
+  # the self.stack method, which will be used to create a new
+  # Orange::Stack
+  class Application
+    extend ClassInheritableAttributes
+    cattr_accessor :core, :stack_block
+    # Initialize will set the core, and additionally accept any
+    # other options to be added in to the opts array
+    # @param [Orange::Core] core the orange core instance that this application will use
+    # @param [Hash] *opts the optional arguments
+    def initialize(core = false, *opts, &block)
+      @core = core || self.class.core
+      @options ||= {}
+      @options = Orange::Options.new(*opts, &block).hash.with_defaults(self.class.opts)
+      @core.application(self) # Register self into core
+      init
+    end
+    
+    # stack_init is ONLY called after the {#app} 
+    # method is called, loading a stack
+    # (just in case the middleware stack added necessary functionality, etc)
+    def stack_init
+    end
+    
+    # This method is called by initialize, subclasses should override this method
+    # for their own initialization needs.
+    # 
+    # It will usually be better to use stack_init, which gives full access to
+    # the initialized stack
+    def init
+    end
+    
+    # Set the orange core to be a new core
+    #
+    # Generally, the core should be set during initialization, rather
+    # than with this method.
+    # @param [Orange::Core] core the orange core instance
+    def set_core(core)
+      @core = core
+    end
+    
+    # The standard call as required by rack. This will 
+    # make an Orange::Packet object (if necessary) and
+    # then send it to the appropriate router for routing.
+    #
+    # If the :self_routing option is true (default) then
+    # the packet will be routed by the application if there
+    # is not already another class volunteering for that role.
+    # (Routers declare themselves in the orange 
+    # env['route.router'] to be called by the application)
+    # 
+    # 
+    def call(env)
+      packet = Orange::Packet.new(@core, env)
+      # Set up this application as router if nothing else has
+      # assumed routing responsibility (for Sinatra DSL like routing)
+      self_routing = opts[:self_routing] || true
+      if (!packet['route.router'] && self_routing)
+        packet['route.router'] = self
+      end
+      packet.route
+      packet.finish
+    end
+    
+    # Returns the core
+    # @return [Orange::Core] the core instance set for the application
+    def orange
+      @core
+    end
+    
+    # The default route method for the application. Must be overridden in subclasses.
+    # 
+    # This method will raise a RuntimeError if not overridden.
+    # The intent is for the application subclass to override this method
+    # and use it to handle packets not routed by Stack middleware.
+    def route(packet)
+      raise "default response from Orange::Application.route"
+    end
+    
+    # Used to set optional values at class level. Will be merged into the options
+    # given at initialization time
+    def self.set(key, v = true)
+      @class_opts ||= {}
+      @class_opts[key] = v
+    end
+    
+    # Gives access to class defined options. 
+    def self.opts
+      @class_opts ||= {}
+    end
+    
+    # Gives access to options for the application, both from the class and the 
+    # instance level. 
+    # @return [Hash] the options hash
+    def opts
+      @options
+    end
+    
+    # Returns an instance of Orange::Stack to be run by Rack
+    #
+    # Usually, you'll call this in the rackup file: `run MyApplication.app`
+    def self.app(c = false)
+      if c
+        self.core = c 
+      else
+        self.core ||= Orange::Core.new
+      end
+      return self.core.stack unless self.core.stack.blank?
+      if self.stack_block.instance_of?(Proc)
+        Orange::Stack.new self, self.core, &self.stack_block   # turn saved proc into a block arg
+      else
+        Orange::Stack.new self, self.core
+      end
+    end
+    
+    # Changes the stack that will be used when {#app}
+    # is called
+    # 
+    # Each call to stack overrides the previous one.
+    def self.stack(core = false, &block)
+      self.core = core if core
+      self.stack_block = Proc.new           # pulls in the block and makes it a proc
+    end
+  end
+end

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

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

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

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