orange-core 0.5.3

data/lib/orange-core/plugin.rb

@@ -0,0 +1,172 @@
+require 'orange-core/magick'
+require 'orange-core/core'
+module Orange::Plugins
+  # This class defines a basic Orange plugin. A plugin simply defines
+  # a bunch of possible classes/files that can be called up by the main
+  # orange system.
+  # 
+  # The plugins are used in several places. When the core is initialized,
+  # it will ask all plugins if they have any resources that should be added,
+  # and load those resources if they exist.
+  # 
+  # The stack will call the list of plugins several times in building a stack
+  # once for each possible middleware location. 
+  class Base
+    extend ClassInheritableAttributes
+    cattr_accessor  :prerouting_middleware, :routing_middleware, 
+                    :responder_middleware, :postrouting_middleware, :has_middleware
+    cattr_accessor :assets, :assets_name
+    cattr_accessor :resources
+    cattr_accessor :views
+    cattr_accessor :templates
+    
+    # Adds a single prerouting middleware class to list of prerouting middleware
+    def self.prerouter(r)
+      prerouters(r)
+    end
+    
+    # Adds several prerouting middleware classes to list of prerouting middleware
+    def self.prerouters(*routers)
+      self.has_middleware = true
+      routers.each do |prerouter|
+        self.prerouting_middleware << prerouter
+      end
+    end
+    
+    # Adds a single postrouting middleware class to list of postrouting middleware
+    def self.postrouter(r)
+      postrouters(r)
+    end
+    
+    # Adds several postrouting middleware classes to list of postrouting middleware
+    def self.postrouters(*routers)
+      self.has_middleware = true
+      routers.each do |postrouter|
+        self.postrouting_middleware << postrouter
+      end
+    end
+    
+    # Adds a router middleware class to the list of routing middleware
+    def self.router(r)
+      routers(r)
+    end
+    # Adds several router middleware classes
+    def self.routers(*routers)
+      self.has_middleware = true
+      routers.each do |router|
+        self.routing_middleware << router
+      end
+    end
+    # Adds a responder middleware class 
+    def self.responder(r)
+      responders(r)
+    end
+    # Adds several responder middleware classes
+    def self.responders(*respones)
+      self.has_middleware = true
+      respones.each do |response|
+        self.responder_middleware << response
+      end
+    end
+    
+    # Returns the list of prerouting_middleware defined or
+    # an empty array if none defined
+    def self.prerouting_middleware
+      super || self.prerouting_middleware = []
+    end
+    
+    # Returns the list of prerouting_middleware defined or
+    # an empty array if none defined
+    def self.postrouting_middleware
+      super || self.postrouting_middleware = []
+    end
+    
+    # Returns the list of routing_middleware defined or
+    # an empty array if none defined
+    def self.routing_middleware
+      super || self.routing_middleware = []
+    end
+    
+    # Returns the list of responder_middleware defined or
+    # an empty array if none defined
+    def self.responder_middleware
+      super || self.responder_middleware = []
+    end
+    
+    def self.templates_dir(arg)
+      self.templates = arg
+    end
+    
+    def self.views_dir(arg)
+      self.views = arg
+    end
+    
+    def self.assets_dir(arg)
+      self.assets = arg
+    end
+    
+    def self.resource(instance, name = false)
+      self.resources << [instance, name]
+    end
+    
+    def self.resources
+      super || self.resources = []
+    end
+    
+    # Returns the assigned asset dir name,
+    # or Plugin class name formatted like this: PluginClass -> _pluginclass_
+    def assets_name
+      self.class.assets_name || '_'+self.class.to_s.gsub(/Orange::Plugins::/, '').gsub(/::/, '_').downcase+'_'
+    end
+    
+    # Returns the assets directory for this plugin
+    def assets
+      self.class.assets
+    end
+    
+    # Whether this plugin has assets for the static middleware to worry
+    # about
+    def has_assets?
+      !assets.blank?
+    end
+    
+    def resources
+      self.class.resources
+    end
+    
+    def has_resources?
+      !resources.blank?
+    end
+    
+    def views
+      self.class.views
+    end
+    
+    def has_views?
+      !views.blank?
+    end
+    
+    def templates
+      self.class.templates
+    end
+    
+    def has_templates?
+      !templates.blank?
+    end
+    
+    def middleware(type = :has)
+      case type
+      when :responders then self.class.responder_middleware
+      when :routing then self.class.routing_middleware
+      when :prerouting then self.class.prerouting_middleware
+      when :postrouting then self.class.postrouting_middleware
+      when :has then self.class.has_middleware
+      else nil
+      end
+    end
+    
+    def has_middleware?
+      !middleware.blank?
+    end
+  end
+end

data/lib/orange-core/resource.rb

@@ -0,0 +1,96 @@
+require 'orange-core/core'
+
+module Orange
+  # Orange Resource for being subclassed
+  class Resource
+    extend ClassInheritableAttributes
+    # Defines a model class as an inheritable class attribute and also an instance
+    # attribute
+    cattr_accessor :called
+    
+    def initialize(*args, &block)
+      @options = DefaultHash.new.merge!(Options.new(*args, &block).hash)
+    end
+    
+    def set_orange(orange, name)
+      @orange = orange
+      @my_orange_name = name
+      init
+      orange.register(:stack_loaded) { |s| stack_init } if self.respond_to? :stack_init
+      self
+    end
+    
+    def self.set_orange(*args)
+      raise 'instantiate the resource before calling set orange'
+    end
+    
+    def init
+      afterLoad
+    end
+    
+    def afterLoad
+    end
+    
+    def self.call_me(name)
+      self.called = name
+    end
+    
+    def orange
+      @orange
+    end
+    
+    def routable
+      false
+    end
+    
+    def view(packet = false, *args)
+      ''
+    end
+    
+    def orange_name
+      @my_orange_name || self.class.called || false
+    end
+    
+    def options
+      @options 
+    end
+    
+    # Renders a view, with all options set for haml to access.
+    # Calls #view_opts to generate the haml options. 
+    # @param [Orange::Packet] packet the packet we are returning a view for
+    # @param [Symbol] mode the mode we are trying to view (used to find template name)
+    # @param [optional, Array] args the args array
+    # @return [String] haml parsed string to be placed in packet[:content] by #route
+    def do_view(packet, mode, *args)
+      haml_opts = view_opts(packet, mode, *args)
+      orange[:parser].haml("#{mode.to_s}.haml", packet, haml_opts)
+    end
+    
+    
+    # Returns the options for including in template rendering. All keys passed in the args array
+    # will automatically be local variables in the haml template.
+    # In addition, the props, resource, and model_name variables will be available.
+    # @param [Orange::Packet] packet the packet we are returning a view for
+    # @param [Symbol] mode the mode we are trying to view (used to find template name)
+    # @param [boolean] is_list whether we want a list or not (view_opts will automatically look up
+    #   a single object or a list of objects, so we need to know which)
+    # @param [optional, Array] args the args array
+    # @return [Hash] hash of options to be used
+    def view_opts(packet, mode, *args)
+      opts = args.extract_options!.with_defaults({:path => ''})
+      all_opts = {:resource => self, :model_name => @my_orange_name}.merge!(opts)
+      all_opts.with_defaults! find_extras(packet, mode)
+      all_opts
+    end
+    
+    # Returns a hash of extra options to be set and made available by the haml parser.
+    # Overriding this method is useful for passing extra bits of info to rendering
+    # for certain view modes without rewriting all of the other scaffolding
+    # @param [Orange::Packet] packet the packet we are returning a view for
+    # @param [Symbol] mode the mode we are trying to view (used to find template name)
+    # @return [Hash] a hash of extras to be included in the rendering
+    def find_extras(packet, mode)
+      {}
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'orange-core/core'
+
+module Orange
+  class Mapper < Resource
+    # Takes a packet extracts request information, then calls packet.route
+    def afterLoad
+      orange.add_pulp Pulp::Packet_Mapper
+    end
+    
+    def route_to(packet, resource, *args)
+      opts = args.extract_options!
+      packet = DefaultHash.new unless packet 
+      context = opts[:context]
+      context = packet['route.context', nil] unless (context || (packet['route.context'] == :live))
+      site = packet['route.faked_site'] ? packet['route.site_url', nil] : nil
+      args.unshift(resource)
+      args.unshift(context)
+      args.unshift(site)
+      '/'+args.compact.join('/')
+    end
+  end
+  
+  module Pulp::Packet_Mapper
+    def route_to(resource, *args)
+      orange[:mapper].route_to(self, resource, *args)
+    end
+    
+    def reroute(url, type = :real, *args)
+      packet['reroute.to'] = url
+      packet['reroute.type'] = type
+      packet['reroute.args'] = *args if args
+      raise Reroute.new(self), 'Unhandled reroute'
+    end
+  end
+  
+end

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

@@ -0,0 +1,228 @@
+require 'orange-core/resources/routable_resource'
+
+module Orange
+  class ModelResource < RoutableResource
+    # Defines a model class as an inheritable class attribute and also an instance
+    # attribute
+    cattr_accessor :model_class
+    attr_accessor :model_class
+    
+    # Tells the Model resource which Carton class to scaffold
+    # @param [Orange::Carton] my_model_class class name of the carton class to scaffold
+    def self.use(my_model_class)
+      self.model_class = my_model_class
+    end
+    
+    # Overrides the instantiation of new Resource object to set instance model
+    # class to the class-level model class defined by #use
+    def self.new(*args, &block)
+      me = super(*args, &block)
+      me.model_class = self.model_class 
+      me
+    end
+    
+    # Views a packet by calling method defined as opts[:mode].
+    # Defaults mode to show or list, if it can't find opts[:mode].
+    # Decision between show or list is determined by whether an id has been chosen.
+    # An id is set in opts[:id], or extracted from the packet['route.resource_id']. 
+    # Calling view is equivalent to calling a viewable method directly, view just
+    # sets up safe defaults so method missing errors are less likely.
+    # @param [Orange::Packet] packet the packet calling view on this resource
+    def view(packet, opts = {})
+      resource_id = opts[:id] || packet['route.resource_id', false]
+      mode = opts[:mode] || packet['route.resource_action'] || 
+        (resource_id ? :show : :index)
+      self.__send__(mode, packet, opts)
+    end
+    
+    # Renders a view, with all options set for haml to access.
+    # Calls #view_opts to generate the haml options. 
+    # @param [Orange::Packet] packet the packet we are returning a view for
+    # @param [Symbol] mode the mode we are trying to view (used to find template name)
+    # @param [optional, Array] args the args array
+    # @return [String] haml parsed string to be placed in packet[:content] by #route
+    def do_view(packet, mode, *args)
+      haml_opts = view_opts(packet, mode, false, *args)
+      orange[:parser].haml("#{mode.to_s}.haml", packet, haml_opts)
+    end
+    
+    # Renders a view, with all options set for haml to access. Same as do_view, but
+    # calls #view_opts with is_list set to true to generate the haml options.
+    # @param [Orange::Packet] packet the packet we are returning a view for
+    # @param [Symbol] mode the mode we are trying to view (used to find template name)
+    # @param [optional, Array] args the args array
+    # @return [String] haml parsed string to be placed in packet[:content] by #route
+    def do_list_view(packet, mode, *args)
+      haml_opts = view_opts(packet, mode, true, *args)
+      orange[:parser].haml("#{mode.to_s}.haml", packet, haml_opts)
+    end
+    
+    # Returns the options for including in template rendering. All keys passed in the args array
+    # will automatically be local variables in the haml template.
+    # In addition, the props, resource, and model_name variables will be available.
+    # @param [Orange::Packet] packet the packet we are returning a view for
+    # @param [Symbol] mode the mode we are trying to view (used to find template name)
+    # @param [boolean] is_list whether we want a list or not (view_opts will automatically look up
+    #   a single object or a list of objects, so we need to know which)
+    # @param [optional, Array] args the args array
+    # @return [Hash] hash of options to be used
+    def view_opts(packet, mode, is_list, *args)
+      opts = args.extract_options!.with_defaults({:path => ''})
+      props = model_class.form_props(packet['route.context'])
+      resource_id = opts[:id] || packet['route.resource_id'] || false
+      all_opts = {:props => props, :resource => self, :model_name => @my_orange_name}.merge!(opts)
+      all_opts.with_defaults! :model => find_one(packet, mode, resource_id) unless is_list
+      all_opts.with_defaults! :list => find_list(packet, mode) if is_list
+      all_opts.with_defaults! find_extras(packet, mode)
+      all_opts
+    end
+    
+    # Returns a single object found by the model class, given an id. 
+    # If id isn't given, we return false.
+    # @param [Orange::Packet] packet the packet we are returning a view for
+    # @param [Symbol] mode the mode we are trying to view (used to find template name)
+    # @param [Numeric] id the id to lookup on the model class
+    # @return [Object] returns an object of type set by #use, if one found with same id
+    def find_one(packet, mode, id = false)
+      return false unless id
+      model_class.get(id) 
+    end
+    
+    # Returns a list of all objects found by the model class
+    # If none, returns an empty array
+    # @param [Orange::Packet] packet the packet we are returning a view for
+    # @param [Symbol] mode the mode we are trying to view (used to find template name)
+    # @param [Numeric] id the id to lookup on the model class
+    # @return [Enumerable] returns a collection of objects of type set by #use
+    def find_list(packet, mode)
+      model_class.all || []
+    end
+    
+    # Creates a new model object and saves it (if a post), then reroutes to the main page
+    # @param [Orange::Packet] packet the packet being routed
+    def new(packet, opts = {})
+      no_reroute = opts.delete(:no_reroute)
+      if packet.request.post? || !opts.blank?
+        params = opts.with_defaults(opts.delete(:params) || packet.request.params[@my_orange_name.to_s] || {})
+        before = beforeNew(packet, params)
+        obj = onNew(packet, params) if before
+        afterNew(packet, obj, params) if before
+        obj.save if obj && before
+      end
+      packet.reroute(@my_orange_name, :orange) unless (packet.request.xhr? || no_reroute)
+      obj || false
+    end
+    
+    # A callback for the actual new item event
+    def onNew(packet, opts = {})
+      model_class.new(opts)
+    end
+    
+    # A callback for before a new item is created
+    # @param [Orange::Packet] packet the packet being routed
+    def beforeNew(packet, opts = {})
+      true
+    end
+    
+    # A callback for after a new item is created
+    # @param [Orange::Packet] packet the packet being routed
+    # @param [Object] obj the model class just created
+    def afterNew(packet, obj, opts = {})
+    end
+    
+    # Deletes an object specified by packet['route.resource_id'], then reroutes to main.
+    # The request must come in as a delete. Rack::MethodOverride can be used to do this.
+    # @param [Orange::Packet] packet the packet being routed
+    def delete(packet, opts = {})
+      no_reroute = opts.delete(:no_reroute)
+      if packet.request.delete? || !opts.blank?
+        id = opts.delete(:resource_id) || packet['route.resource_id']
+        m = model_class.get(packet['route.resource_id'])
+        before = beforeDelete(packet, m, opts)
+        onDelete(packet, m, opts) if m && before
+        afterDelete(packet, m, opts) if before
+        orange.fire(:model_resource_deleted, packet, {:resource_id => id, :resource => @my_orange_name})
+      end
+      packet.reroute(@my_orange_name, :orange) unless (packet.request.xhr? || no_reroute)
+    end
+    
+    def beforeDelete(packet, obj, opts = {})
+      true
+    end
+    
+    # Delete object
+    def onDelete(packet, obj, opts = {})
+      obj.destroy
+    end
+    
+    def afterDelete(packet, obj, opts = {})
+    end
+    
+    # Saves updates to an object specified by packet['route.resource_id'], then reroutes to main
+    # @param [Orange::Packet] packet the packet being routed
+    def save(packet, opts = {})
+      no_reroute = opts.delete(:no_reroute)
+      if packet.request.post? || !opts.blank?
+        my_id = opts.delete(:resource_id) || packet['route.resource_id']
+        m = opts.delete(:model) || model_class.get(my_id)
+        params = opts.with_defaults(opts.delete(:params) || packet.request.params[@my_orange_name.to_s] || {})
+        if m
+          before = beforeSave(packet, m, params)
+          onSave(packet, m, params) if before
+          afterSave(packet, m, params) if before
+        end
+      end
+      packet.reroute(@my_orange_name, :orange) unless (packet.request.xhr? || no_reroute)
+      m || false
+    end
+    
+    def beforeSave(packet, obj, opts = {})
+      true
+    end
+    
+    def onSave(packet, obj, opts = {})
+      obj.update(opts)
+    end
+    
+    def afterSave(packet, obj, opts = {})
+    end
+    
+    # Calls #do_view with :show mode
+    # @param [Orange::Packet] packet the packet being routed
+    def show(packet, *opts)
+      do_view(packet, :show, *opts)
+    end
+    
+    # Calls #do_view with :edit mode
+    # @param [Orange::Packet] packet the packet being routed
+    def edit(packet, *opts)
+      do_view(packet, :edit, *opts)
+    end
+    
+    # Calls #do_view with :create mode
+    # @param [Orange::Packet] packet the packet being routed
+    def create(packet, *opts)
+      do_view(packet, :create, *opts)
+    end
+    
+    # Calls #do_view with :table_row mode
+    # @param [Orange::Packet] packet the packet being routed
+    def table_row(packet, *opts)
+      do_view(packet, :table_row, *opts)
+    end
+    
+    # Calls #do_list_view with :list mode
+    # @param [Orange::Packet] packet the packet being routed
+    def list(packet, *opts)
+      do_list_view(packet, :list, *opts)
+    end
+    
+    # Calls #do_list_view with :list mode. 
+    # @param [Orange::Packet] packet the packet being routed
+    def index(packet, *opts)
+      do_list_view(packet, :list, *opts)
+    end
+  
+  end
+  
+end