orange 0.0.2

data/README.markdown

@@ -0,0 +1,154 @@
+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. Our main focus is on creating a super-extensible CMS
+with Orange, but we're trying to make the components as reusable as possible. Our
+intention is to be ready to use Orange for most client website builds by
+March 2010. 
+
+**Note**: Orange is still in the alpha stage. Test coverage is lack-luster at best. 
+Tread carefully.
+
+A (Theoretical) Example of Orange
+=================================
+
+_This doesn't actually work quite yet, but it's the goal we're working toward._
+
+After installing the orange gem, create an 'app.rb'
+
+**app.rb:**
+
+    require 'rubygems'
+    require 'orange'
+    class App < Orange::Application
+    end
+
+You now have an Orange CMS that can be made by calling "App.app". 
+Put this line in your rackup file...
+
+**config.ru:**
+
+    require 'app'
+    run App.app
+
+Run rack however you run rack. 
+
+Look at that, a full fledged CMS in 6 lines! Not so impressive, it's all prebuilt, 
+right? The real question is how hard is it to customize?
+
+I want my pages to have more than just titles and bodies. I want sidebars...
+
+**app.rb:**
+
+    require 'rubygems'
+    require 'orange'
+    class App < Orange::Application
+    end
+    class Orange::Page
+       markdown :sidebar, :context => [:front]
+    end
+
+We now have a sidebar that anybody can see. The backend scaffolding will adapt to allow 
+editing, and the front end will print it out for each page. Slap some CSS on it to make it 
+look like a sidebar, and tada! 
+
+Pages now have sidebars, in three lines of code and some
+styling. No migrations (we rely on DataMapper's auto_upgrade functionality), no extra
+files (unless we want them).
+
+More Info
+=========
+
+Orange Philosophy
+-----------------
+The Orange application framework is intended to be a fully customizable CMS
+capable of hosting multiple sites while maintaining Sinatra-like ease of 
+programming. Some core ideas behind Orange:
+
+* Scaffolding doesn't have to be replaced if it's smart enough (most of the time)
+* 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?
+--------------------
+Not right now, unless you want to write half the framework yourself.
+
+
+When it's finished, would I want to use it?
+-------------------------------------------
+Depends on what you're looking for. Orange has a middleware stack intended to 
+be reused. If the stack has something you'd like, you could theoretically
+put the middleware stack on top of Sinatra or Rails. (This hasn't actually
+been tested yet.)
+
+The full Orange application framework is intended to run
+as an easily extensible CMS. We tend to think that having lots of tests
+and full MVC separation just so you can add an extra type of page to the CMS 
+is a bit overkill. We designed this to replace ModX in our web builds for clients. 
+
+Required Gems
+-------------
+
+Make sure githubs gems can be downloaded:
+
+    $ gem sources -a http://gems.github.com
+
+* dm-core (+ do_[sqlite3|mysql|...] )
+* dm-more
+* rack
+* haml
+* mynyml-rack-abstract-format (github)
+* ruby-openid
+* rack-openid
+* meekish-openid_dm_store
+
+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
+    
+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.

data/lib/orange.rb

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

data/lib/orange/application.rb

@@ -0,0 +1,125 @@
+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
+    # 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
+      @options ||= {}
+      @options = Orange::Options.new(*opts, &block).hash.with_defaults(self.class.opts)
+      orange.register(:stack_loaded) do |s|
+        stack_init
+      end
+      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
+      if @app.instance_of?(Proc)
+        Orange::Stack.new &@app   # turn saved proc into a block arg
+      else
+        Orange::Stack.new self
+      end
+    end
+    
+    # Changes the stack that will be used when {#app}
+    # is called
+    # 
+    # Each call to stack overrides the previous one.
+    def self.stack(&block)
+      @app = Proc.new           # pulls in the block and makes it a proc
+    end
+  end
+end

data/lib/orange/carton.rb

@@ -0,0 +1,114 @@
+require 'dm-core'
+
+module Orange
+  class Carton
+    
+    def self.as_resource
+      name = self.to_s
+      eval <<-HEREDOC
+      class ::#{name}_Resource < Orange::ModelResource
+        use #{name}
+      end
+      HEREDOC
+    end
+    
+    # Info for 
+    include DataMapper::Types
+    
+    def self.id
+      include DataMapper::Resource
+      self.property(:id, Serial)
+      @scaffold_properties = []
+      init
+    end
+    
+    def self.init
+    end
+    
+    # Return properties that should be shown for a given context
+    def self.form_props(context)
+      @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
+    
+    # Define a helper for title type database stuff
+    # Show in a context if wrapped in one of the helpers
+    def self.title(name, opts = {})
+      @scaffold_properties << {:name => name, :type => :title, :levels => @levels}.merge(opts) if @levels
+      self.property(name, String, 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 = {})
+      @scaffold_properties << {:name => name, :type => :fulltext, :levels => @levels, :opts => opts} if @levels
+      self.property(name, Text, 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 = {})
+      @scaffold_properties << {:name => name, :type => :text, :levels => @levels, :opts => opts} if @levels
+      self.property(name, String, 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.string(name, opts = {})
+      self.text(name, opts)
+    end
+    
+    # Override DataMapper to include context sensitivity (as set by helpers)
+    def self.property(name, type, opts = {})
+      my_type = type.to_s.downcase.to_sym
+      @scaffold_properties << {:name => name, :type => my_type, :levels => @levels}.merge(opts) if @levels
+      property(name, type, opts)
+    end
+      
+    
+    # For more generic cases, use same syntax as DataMapper
+    # This will make it an admin property though.
+    def self.admin_property(name, type, opts = {})
+      my_type = type.to_s.downcase.to_sym
+      @scaffold_properties << {:name => name, :type => my_type, :levels => [:admin, :orange]}.merge(opts)
+      property(name, type, opts)
+    end
+    
+    # For more generic cases, use same syntax as DataMapper
+    # This will make it a front property though.
+    def self.front_property(name, type, opts = {})
+      my_type = type.to_s.downcase.to_sym
+      @scaffold_properties << {:name => name, :type => my_type, :levels => [:live, :admin, :orange]}.merge(opts)
+      property(name, type, opts)
+    end
+    
+    # For more generic cases, use same syntax as DataMapper
+    # This will make it an orange property though.
+    def self.orange_property(name, type, opts = {})
+      my_type = type.to_s.downcase.to_sym
+      @scaffold_properties << {:name => name, :type => my_type, :levels => [:orange]}.merge(opts)
+      property(name, type, opts)
+    end
+    
+  end
+end

data/lib/orange/cartons/site_carton.rb

@@ -0,0 +1,9 @@
+require 'dm-core'
+
+module Orange
+  class SiteCarton < Carton
+    def self.init
+      belongs_to :orange_site, 'Orange::Site'
+    end
+  end
+end

data/lib/orange/core.rb

@@ -0,0 +1,197 @@
+require 'dm-core'
+require 'rack'
+require 'rack/builder'
+
+module Orange
+  # Declare submodules for later use
+  module Pulp; end
+  module Mixins; 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 = {}
+      @events = {}
+      @file = __FILE__
+      load(Orange::Parser.new, :parser)
+      load(Orange::Mapper.new, :mapper)
+      load(Orange::PageParts.new, :page_parts)
+      afterLoad
+      self
+    end
+    
+    # Returns the orange library directory
+    # @return [String] the directory name indicating where the core file is
+    #   located
+    def core_dir
+      options[:core_dir] ||= File.dirname(__FILE__)
+    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
+      options[:app_dir] ||= Dir.pwd
+    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.class.to_s.gsub(/::/, '_').downcase.to_sym if(!name) 
+      @resources[name] = resource.set_orange(self, name)
+    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)
+      return false unless @events[event]
+      @events[event].compact!
+      for callback in @events[event]
+        callback.call(packet)
+      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
+    # @return [Orange::Resource] the resource for the given short name
+    def [](name)
+      @resources[name]
+    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
+  end
+end