orange 0.0.3 → 0.0.4

data/lib/orange/application.rb

@@ -81,7 +81,7 @@ module Orange
     # 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'
+      raise "default response from Orange::Application.route"
     end
     
     # Used to set optional values at class level. Will be merged into the options

data/lib/orange/carton.rb

@@ -7,7 +7,9 @@ module Orange
   #
   # 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. 
+  # 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`)
@@ -15,8 +17,14 @@ module Orange
   # 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] unless defined?(SCAFFOLD_OPTIONS)
+    # 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
@@ -26,22 +34,28 @@ module Orange
       HEREDOC
     end
     
-    # Info for 
+    # 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
-      self.property(:id, Serial)
+      property(:id, Serial)
       @scaffold_properties = []
       init
     end
     
+    def self.scaffold_properties
+      @scaffold_properties ||= []
+    end
+    
+    # Stub init method
     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)  }
+    def self.form_props(context = :live)
+      scaffold_properties.select{|p| p[:levels].include?(context)  }
     end
     
     # Helper to wrap properties into admin level
@@ -65,25 +79,40 @@ module Orange
       @levels = false
     end
     
+    def self.add_scaffold(name, type, dm_type, opts)
+      scaffold_properties << {:name => name, :type => type, :levels => @levels}.merge(opts) if @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 = {})
-      @scaffold_properties << {:name => name, :type => :title, :levels => @levels}.merge(opts) if @levels
-      self.property(name, String, opts)
+      add_scaffold(name, :title, 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)
+      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 = {})
-      @scaffold_properties << {:name => name, :type => :text, :levels => @levels, :opts => opts} if @levels
-      self.property(name, String, 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 = {})
+      scaffold_properties << {:name => name, :type => :text, :levels => @levels, :opts => opts} if @levels
     end
     
     # Define a helper for input type="text" type database stuff
@@ -93,35 +122,34 @@ module Orange
     end
     
     # Override DataMapper to include context sensitivity (as set by helpers)
-    def self.property(name, type, opts = {})
+    def self.scaffold_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)
+      add_scaffold(name, my_type, type, opts)
     end
       
     
-    # For more generic cases, use same syntax as DataMapper
-    # This will make it an admin property though.
+    # 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
-      @scaffold_properties << {:name => name, :type => my_type, :levels => [:admin, :orange]}.merge(opts)
-      property(name, type, opts)
+      opts[:levels] = [:admin, :orange]
+      add_scaffold(name, my_type, type, opts)
     end
     
-    # For more generic cases, use same syntax as DataMapper
-    # This will make it a front property though.
+    # 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
-      @scaffold_properties << {:name => name, :type => my_type, :levels => [:live, :admin, :orange]}.merge(opts)
-      property(name, type, opts)
+      opts[:levels] = [:live, :admin, :orange]
+      add_scaffold(name, my_type, type, opts)
     end
     
-    # For more generic cases, use same syntax as DataMapper
-    # This will make it an orange property though.
+    # 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
-      @scaffold_properties << {:name => name, :type => my_type, :levels => [:orange]}.merge(opts)
-      property(name, type, opts)
+      opts[:levels] = [:orange]
+      add_scaffold(name, my_type, type, opts)
     end
     
   end

data/lib/orange/cartons/site_carton.rb

@@ -1,6 +1,9 @@
-require 'dm-core'
+require 'orange/carton'
 
 module Orange
+  # Defines a carton that belongs to a specific site.
+  # (Subclasses should be sure to call super if they override init, since
+  # it is what defines the relationship)
   class SiteCarton < Carton
     def self.init
       belongs_to :orange_site, 'Orange::Site'

data/lib/orange/core.rb

@@ -57,6 +57,7 @@ module Orange
       load(Orange::Parser.new, :parser)
       load(Orange::Mapper.new, :mapper)
       load(Orange::PageParts.new, :page_parts)
+      load(Orange::AdminResource.new, :admin)
       afterLoad
       self
     end
@@ -165,9 +166,16 @@ module Orange
     # 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)
-      @resources[name]
+    def [](name, ignore = false)
+      if ignore && !loaded?(name)
+        Ignore.new
+      else
+        @resources[name]
+      end 
     end
     
     # Includes module in the Packet class

data/lib/orange/magick.rb

@@ -64,6 +64,17 @@ module Orange
     end
   end
   
+  # This class acts as a simple sink for ignoring messages, it will return itself
+  # for any message call. Orange::Core can optionally return this when trying 
+  # to access resources so that you can make method calls to a resource that 
+  # might not be really there. It will silently swallow any errors that might arrise,
+  # so this should be used with caution.
+  class Ignore
+    def method_missing(name, *args, &block)
+      return self
+    end
+  end
+  
   # Simple class for evaluating options and allowing us to access them.
   class Options
     

data/lib/orange/middleware/access_control.rb

@@ -3,13 +3,23 @@ require 'orange/middleware/base'
 
 
 module Orange::Middleware
-  
+  # This middleware locks down entire contexts and puts them behind an openid 
+  # login system. Currently only supports a single user id. 
+  #
+  # 
   class AccessControl < Base
-    def init(*args)
+    # Sets up the options for the middleware
+    # @param [Hash] opts hash of options
+    # @option opts [Boolean] :openid Whether to use openid logins or not (currently only option)
+    # @option opts [Boolean] :handle_login Whether the access control system should handle 
+    #   presenting the login form, or let other parts of the app do that. 
+    # @option opts [Boolean] :config_id Whether to use the id set in a config file
+    
+    def init(opts = {})
       defs = {:locked => [:admin, :orange], :login => '/login', 
               :handle_login => true, :openid => true, :config_id => true}
-      opts = args.extract_with_defaults(defs)
-      @openid = opts.has_key?(:openid) ? opts[:openid] : false
+      opts = opts.with_defaults!(defs)
+      @openid = opts[:openid]
       @locked = opts[:locked]
       @login = opts[:login]
       @handle = opts[:handle_login]
@@ -65,15 +75,14 @@ module Orange::Middleware
             packet['user.openid.response'] = resp
             
             after = packet.session.has_key?('user.after_login') ?
-                        packet.session['user.after_login'] : false
+                        packet.session['user.after_login'] : '/'
             packet.session['user.after_login'] = false
             
             # Save id into session if we have one.
             packet.session['user.id'] = packet['user.id']
             
             # If the user was supposed to be going somewhere, redirect there
-            packet.reroute(after) if after
-            packet.reroute('/')
+            packet.reroute(after)
             false
           else
             packet.session['flash.error'] = resp.status

data/lib/orange/middleware/base.rb

@@ -10,30 +10,69 @@ require 'orange/packet'
 # a basic call
 module Orange::Middleware
   class Base
+    # Initialize will set the core and downstream app, then call init
+    # subclasses should override init instead of initialize
+    # @param [Object] app a downstream app 
+    # @param [Orange::Core] core the orange core
+    # @param [optional, Array] args any arguments
     def initialize(app, core, *args)
       @app = app
       @core = core
       init(*args)
     end
     
+    # A stub method that subclasses can override to handle initialization
+    # @return [void]
     def init(*args)
     end
     
+    # The standard Rack "call". By default, Orange Middleware wraps the env into
+    # an Orange::Packet and passes it on to #packet_call. Subclasses will typically
+    # override packet_call rather than overriding call directly. 
+    # 
+    # Orange Middleware
+    # should expect to have this method ignored by upstream Orange-aware apps in
+    # favor of calling packet_call directly.
+    # @param [Hash] env the hash of environment variables given by the rack interface.
+    # @return [Array] the standard Rack striplet of status, headers and content
     def call(env)
       packet = Orange::Packet.new(@core, env)
       packet_call(packet)
     end
     
+    # Like the standard call, but with the env hash already wrapped into a Packet
+    # This is called automatically as part of #call, so subclasses can have a packet
+    # without having to initialize it. It will be called directly by Orange-aware
+    # upstream middleware, skipping the step of initializing the packet during #call.
+    # 
+    # Passing the packet downstream should be done with #pass rather than the Rack
+    # standard @app.call, since #pass will take the packet and do a #packet_call
+    # if possible.
+    # @param [Orange::Packet] packet the packet corresponding to this env
+    # @return [Array] the standard Rack striplet of status, headers and content
     def packet_call(packet)
       pass packet
     end
     
+    # Pass will sent the packet to the downstream app by calling call or packet call.
+    # Calling pass on a packet is the preferred way to call downstream apps, as it
+    # will call packet_call directly if possible (to avoid reinitializing the packet)
+    # @param [Orange::Packet] packet the packet to pass to downstream apps
+    # @return [Array] the standard Rack striplet of status, headers and content
     def pass(packet)
-      @app.call(packet.env)
+      if @app.respond_to?(:packet_call)
+        @app.packet_call(packet)
+      else
+        @app.call(packet.env) 
+      end
     end
     
+    # Accessor for @core, which is the stack's instance of Orange::Core
+    # @return [Orange::Core] the stack's instance of Orange::Core
     def orange;     @core;    end
     
+    # Help stack traces
+    # @return [String] string representing this middleware (#to_s)
     def inspect
       self.to_s
     end

data/lib/orange/middleware/flex_router.rb

@@ -0,0 +1,59 @@
+require 'orange/middleware/base'
+
+module Orange::Middleware
+  class FlexRouter < Base
+    def init(*args)
+      opts = args.extract_options!.with_defaults(:contexts => [:admin, :orange], :root_resource => :not_found)
+      @contexts = opts[:contexts]
+      @root_resource = opts[:root_resource]
+    end
+    
+    # sets resource, resource_id, resource_action and resource_path
+    # /resource/id/action/[resource/path/if/any]
+    # /resource/action/[resource/path/if/any]
+    # 
+    # In future - support for nested resources
+    def packet_call(packet)
+      return (pass packet) if packet['route.router']  # Don't route if other middleware
+                                                      # already has
+      if(@contexts.include?(packet['route.context']))
+        path = packet['route.path'] || packet.request.path_info
+        parts = path.split('/')
+        pad = parts.shift
+        if !parts.empty?
+          resource = parts.shift
+          if orange.loaded?(resource.to_sym)
+            packet['route.resource'] = resource.to_sym
+            if !parts.empty?
+              second = parts.shift
+              if second =~ /^\d+$/
+                packet['route.resource_id'] = second
+                if !parts.empty?
+                  packet['route.resource_action'] = parts.shift.to_sym
+                end
+              else
+                packet['route.resource_action'] = second.to_sym
+              end 
+            end # end check for second part
+          else
+            parts.unshift(resource)
+          end # end check for loaded resource
+        end # end check for nonempty route
+        
+        packet['route.resource'] ||= @root_resource
+        packet['route.resource_path'] = parts.unshift(pad).join('/')
+        packet['route.router'] = self
+      end # End context match if
+      
+      pass packet
+    end
+    
+    def route(packet)
+      resource = packet['route.resource']
+      raise 'resource not found' unless orange.loaded? resource
+      mode = packet['route.resource_action'] || 
+        (packet['route.resource_id'] ? :show : :list)
+      packet[:content] = orange[resource].view packet
+    end
+  end
+end

data/lib/orange/middleware/route_context.rb

@@ -1,7 +1,7 @@
 require 'orange/middleware/base'
 
 module Orange::Middleware
-  # This middleware handles setting orange.env[:context] 
+  # This middleware handles setting orange.env['route.context'] 
   # to a value based on the route, if any. The route is then 
   # trimmed before continuing on.
   class RouteContext < Base
@@ -33,7 +33,7 @@ module Orange::Middleware
           packet['route.context'] = @default
         end
       end
-      @app.call(packet.env)
+      pass packet
     end
   end
 end

data/lib/orange/middleware/route_site.rb

@@ -45,7 +45,7 @@ module Orange::Middleware
       else
         packet['route.site_url'] = request.host
       end
-      @app.call(packet.env)
+      pass packet
     end
   end
 end

data/lib/orange/middleware/show_exceptions.rb

@@ -11,7 +11,9 @@ module Orange::Middleware
   #
   # Be careful when you use this on public-facing sites as it could
   # reveal information helpful to attackers.
-
+  #
+  # Orange::Middleware::ShowExceptions is a slightly modified
+  # version of Rack::ShowExceptions
   class ShowExceptions < Base
     CONTEXT = 7
 

data/lib/orange/middleware/site_load.rb

@@ -11,7 +11,16 @@ module Orange::Middleware
     def packet_call(packet)
       url =  packet['route.site_url']
       site = Orange::Site.first(:url.like => url)
-      packet['site'] = site if site
+      if site
+        packet['site'] = site
+      elsif
+        nil
+      else
+        s = Orange::Site.new({:url => packet['route.site_url'], 
+                              :name => 'An Orange Site'})
+        s.save
+        packet['site'] = s
+      end
       pass packet
     end
   end
@@ -29,5 +38,9 @@ module Orange
   
   class SiteResource < ModelResource
     use Orange::Site
+    def afterLoad
+      orange[:admin, true].add_link('Settings', :resource => @my_orange_name, 
+                                                :text => 'Site')
+    end
   end
 end