orange 0.5.5 → 0.5.7

data/lib/orange-core/resource.rb

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

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

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

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

@@ -1,10 +0,0 @@
-require 'orange-core/resource'
-module Orange
-  class NotFound < Orange::Resource
-    call_me :not_found
-    def route(packet)
-      packet[:content] = orange[:parser].haml("404.haml", packet, :resource => self)
-      packet[:status] = 404
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-require 'orange-core/resource'
-module Orange
-  class PageParts < Resource
-    def afterLoad
-      orange.add_pulp Orange::Pulp::PageParts
-    end
-    
-    def part(packet)
-      unless packet[:page_parts, false]
-        packet[:page_parts] = DefaultHash.new 
-        packet[:page_parts].default = ''
-      end
-      packet[:page_parts]
-    end
-    
-    
-    def add_css(packet, file, opts = {})
-      ie = opts[:ie] || false
-      mod = opts[:module] || 'public'
-        # module set to false gives the root assets dir
-      assets = File.join('assets', mod)
-      file = File.join('', assets, 'css', file)
-      unless packet[:css_files, []].include?(file)
-        if ie
-          part(packet)[:ie_css] = part(packet)[:ie_css] + "<link rel=\"stylesheet\" href=\"#{file}\" type=\"text/css\" media=\"screen\" charset=\"utf-8\" />"
-        else 
-          part(packet)[:css] = part(packet)[:css] + "<link rel=\"stylesheet\" href=\"#{file}\" type=\"text/css\" media=\"screen\" charset=\"utf-8\" />"
-        end
-        packet[:css_files] ||= []
-        packet[:css_files].insert((opts[:position] ? opts[:position] : -1), file)
-      end
-    end
-    
-    def add_js(packet, file, opts = {})
-      ie = opts[:ie] || false
-      mod = opts[:module] || 'public'
-      assets = File.join('assets', mod)
-      file = File.join('', assets, 'js', file)
-      unless packet[:js_files, []].include?(file)
-        if ie
-          part(packet)[:ie_js] = part(packet)[:ie_js] + "<script src=\"#{file}\" type=\"text/javascript\"></script>"
-        else 
-          part(packet)[:js] = part(packet)[:js] + "<script src=\"#{file}\" type=\"text/javascript\"></script>"
-        end
-        packet[:js_files] ||= []
-        packet[:js_files].insert((opts[:position] ? opts[:position] : -1), file)
-      end
-    end
-  end
-  
-  module Pulp::PageParts
-    def part
-      orange[:page_parts].part(packet)
-    end
-    
-    # Feels like part should be plural, no?
-    def parts;    part;     end
-    
-    
-    def add_css(file, opts = {})
-      orange[:page_parts].add_css(packet, file, opts)
-    end
-    
-    def add_js(file, opts = {})
-      orange[:page_parts].add_js(packet, file, opts)
-    end
-  end
-end

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

@@ -1,113 +0,0 @@
-require 'orange-core/core'
-require 'haml'
-require 'yaml'
-require 'crack'
-
-module Orange
-  class Parser < Resource
-    def afterLoad
-      orange.add_pulp Orange::Pulp::ParserPulp
-      @template_dirs = [File.join(orange.core_dir, 'templates')]
-      @view_dirs = [File.join(orange.core_dir, 'views')]
-      Orange.plugins.each{|p| @template_dirs << p.templates if p.has_templates? }
-      Orange.plugins.each{|p| @view_dirs << p.views if p.has_views? }
-    end
-    
-    def yaml(file)
-      return nil unless File.exists?(file)
-      string = File.read(file) 
-      string.gsub!('__ORANGE__', orange.app_dir)
-      out = YAML::load(string)
-    end
-    
-    def haml(file, packet_binding, *vars, &block)
-      
-      opts = vars.extract_options!
-      # Initial info
-      temp = opts.delete(:template)
-      opts[:resource_name] = opts[:resource].orange_name.to_s if 
-          opts[:resource] && opts[:resource].respond_to?(:orange_name)
-      resource = (opts[:resource_name] || '').downcase
-      
-      if packet_binding.is_a? Orange::Packet
-        context = packet_binding['route.context'].to_s
-        unless temp
-          packet_binding['parser.haml-templates'] ||= {}
-          haml_engine = packet_binding['parser.haml-templates']["#{context}-#{resource}-#{file}"] || false
-        end
-      end
-      unless haml_engine
-        opts.merge :orange => orange
-      
-        string = false
-        if temp
-          string ||= read_if_exists('templates', file) 
-          @template_dirs.each do |templates_dir|
-            string ||= read_if_exists(templates_dir, file)
-          end unless string
-        end
-      
-        if context
-          #Check for context specific overrides
-          string ||= read_if_exists('views', resource, context+"."+file) if resource
-          string ||= read_if_exists('views', context+"."+file)
-          @view_dirs.each do |views_dir|
-            string ||= read_if_exists(views_dir, resource, context+"."+file) if resource
-            string ||= read_if_exists(views_dir, context+"."+file)
-          end unless string
-        end
-      
-        # Check for standard views
-        string ||= read_if_exists('views', resource, file) if resource
-        string ||= read_if_exists('views', file)
-        @view_dirs.each do |views_dir|
-          string ||= read_if_exists(views_dir, resource, file) if resource
-          string ||= read_if_exists(views_dir, file)
-        end unless string
-      
-        # Check for default resource views
-        string ||= read_if_exists('views', 'default_resource', file)
-        @view_dirs.each do |views_dir|
-          string ||= read_if_exists(views_dir, 'default_resource', file) if resource
-        end unless string
-        raise LoadError, "Couldn't find haml file '#{file}'" unless string
-        
-        haml_engine = Haml::Engine.new(string)
-        if packet_binding.is_a? Orange::Packet
-          packet_binding['parser.haml-templates']["#{context}-#{resource}-#{file}"] = haml_engine
-        end
-      end
-      out = haml_engine.render(packet_binding, opts, &block)
-    end
-    
-    def read_if_exists(*args)
-      return File.read(File.join(*args)) if File.exists?(File.join(*args))
-      false
-    end
-    
-    def hpricot(text)
-      require 'hpricot'
-      Hpricot(text)
-    end
-    
-    def xml(text)
-      Crack::XML.parse(text)
-    end
-    
-    def json(text)
-      Crack::JSON.parse(text)
-    end
-  end 
-  
-  module Pulp::ParserPulp
-    def html(&block)
-      if block_given?
-        unless(packet[:content].blank?)
-          doc = orange[:parser].hpricot(packet[:content])
-          yield doc
-          packet[:content] = doc.to_s
-        end
-      end
-    end
-  end
-end