orange-core 0.5.3

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

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

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

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

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

@@ -0,0 +1,16 @@
+require 'orange-core/resource'
+
+module Orange
+  class RoutableResource < Resource
+    def routable; true; end
+    
+    def route(path, packet)
+      parts = path.split('/')
+      first = parts[0].respond_to?(:to_sym) ? parts.shift.to_sym : :index
+      new_path = parts.join('/')
+      if self.respond_to?(first)
+        packet[:content] = self.__send__(first, new_path, packet)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+require 'orange-core/core'
+
+module Orange
+  class Scaffold < Resource
+    # Load the scaffold helpers
+    def afterLoad
+      orange.add_pulp Pulp::ScaffoldHelpers
+      Packet.meta_methods(/view_([a-zA-Z_]+)/) do |packet, match, args|
+        model = args.shift
+        args = args.extract_with_defaults(:mode => match[1].to_sym)
+        packet.view(model, args)
+      end
+      @scaffold_types = {}
+      add_scaffold_type(:boolean) do |name, val, opts|
+        if opts[:show]
+          val ? "true" : "false"
+        else
+          ret = "<input type='hidden' name='#{opts[:model_name]}[#{name}]' value='0' /><input type='checkbox' name='#{opts[:model_name]}[#{name}]' value='1' #{'checked="checked"' if (val && val != '')}/>"
+          ret = "<label for=''>#{opts[:display_name]}</label><br />" + ret if opts[:label]
+        end
+      end
+    end
+    
+    def add_scaffold_type(type, &block)
+      @scaffold_types[type] = Proc.new
+    end
+    
+    def scaffold_attribute(packet, prop, model_name, *args)
+      args = args.extract_options!
+      args.with_defaults!({:packet => packet, :value => '', :label => false, :show => false})
+      val = args[:value]
+      label = args[:label]
+      show = args[:show]
+      name = prop[:name]
+      human_readable_name = name.to_s.split('_').each{|w| w.capitalize!}.join(' ')
+      display_name = prop[:display_name] || human_readable_name
+      return @scaffold_types[prop[:type]].call(name, val, args.with_defaults!(:display_name => display_name, :model_name => model_name)) if @scaffold_types.has_key?(prop[:type])
+      unless show
+        case prop[:type]
+        when :title
+          val.gsub!('"', '&quot;')
+          ret = "<input class=\"title\" type=\"text\" value=\"#{val}\" name=\"#{model_name}[#{name}]\" />"
+        when :text
+          val.gsub!('"', '&quot;')
+          ret = "<input type=\"text\" value=\"#{val}\" name=\"#{model_name}[#{name}]\" />"
+        when :fulltext
+          ret = "<textarea name='#{model_name}[#{name}]'>#{val}</textarea>"
+        when :boolean
+          human_readable_name = human_readable_name + '?'
+          ret = "<input type='hidden' name='#{model_name}[#{name}]' value='0' /><input type='checkbox' name='#{model_name}[#{name}]' value='1' #{'checked="checked"' if (val && val != '')}/>"
+        when :date
+          val.gsub!('"', '&quot;')
+          ret = "<input class=\"date\" type=\"text\" value=\"#{val}\" name=\"#{model_name}[#{name}]\" />"
+        else
+          val.gsub!('"', '&quot;')
+          ret = "<input type=\"text\" value=\"#{val}\" name=\"#{model_name}[#{name}]\" />"
+        end
+        ret = "<label for=''>#{display_name}</label><br />" + ret if label
+      else
+        case prop[:type]
+        when :title
+          ret = "<h3 class='#{model_name}-#{name}'>#{val}</h3>"
+        when :text
+          ret = "<p class='#{model_name}-#{name}'>#{val}</p>"
+        when :fulltext
+          ret = "<div class='#{model_name}-#{name}'>#{val}</div>"
+        else
+          ret = "<div class='#{model_name}-#{name}'>#{val}</div>"
+        end
+      end
+      return ret
+    end
+  end
+  
+  module Pulp::ScaffoldHelpers
+    # Creates a button that appears to be a link but 
+    # does form submission with custom method (_method param in POST)
+    # This is to avoid issues of a destructive get.
+    # @param [String] text link text to show
+    # @param [String] link the actual href value of the link
+    # @param [String, false] confirm text of the javascript confirm (false for none [default])
+    # @param [optional, Array] args array of optional arguments, only opts[:method] defined
+    # @option opts [String] method method name (Should be 'DELETE', 'PUT' or 'POST')
+    def form_link(text, link, confirm = false, opts = {})
+      text = "<img src='#{opts[:img]}' alt='#{text}' />" if opts[:img]
+      css = opts[:class]? opts[:class] : 'form_button_link'
+      meth = (opts[:method]? "<input type='hidden' name='_method' value='#{opts[:method]}' />" : '')
+      if confirm
+        "<form action='#{link}' method='post' class='mini' onsubmit='return confirm(\"#{confirm}\")'><button class='link_button'><a href='#' class='#{css}'>#{text}</a></button>#{meth}</form>"
+      else
+        "<form action='#{link}' method='post' class='mini'><button class='link_button'><a href='#' class='#{css}'>#{text}</a></button>#{meth}</form>"
+      end
+    end
+    
+    # Calls view for an orange resource. 
+    def view(model_name, *args)
+      orange[model_name].view(self, *args)
+    end
+    
+    # Returns a scaffolded attribute
+    def view_attribute(prop, model_name, *args)
+      orange[:scaffold].scaffold_attribute(self, prop, model_name, *args)
+    end
+  end
+  
+end

data/lib/orange-core/stack.rb

@@ -0,0 +1,226 @@
+require 'orange-core/core'
+require 'rack/builder'
+module Orange
+  # Builds an orange stack of middleware
+  # Use in the rackup file as follows:
+  # app = Orange::Stack.new do 
+  #    stack Orange::DataMapper 'sqlite3::memory:'  <= loads orange specific middleware
+  #    use OtherMiddleware
+  #    run SomeApp.new
+  # end
+  # run app
+  #
+  # All middleware placed inside the Orange::Stack will have access
+  # to the Orange Core (as long as it's been written to accept it as the second
+  # initialization argument) when added with the 'stack' method
+  # 
+  # In general, Orange::Stack works like Rack::Builder.
+  class Stack
+    
+    # Creates a new Orange::Stack out of the passed block.
+    # 
+    # If a block is not passed, it will try to build one from scratch.
+    # The bare minimum will be `run app_class.new(@core)`, there are also
+    # other stacks that can be used.
+    #
+    # @param [Orange::Application] app_class the class of the main application
+    # @param [Orange::Core] core the orange core
+    # @param [Symbol] prebuilt the optional prebuilt stack, if one isn't passed as block
+    def initialize(app_class = nil, core = false, prebuilt = :none, &block)
+      @build = Rack::Builder.new
+      @core = core || Orange::Core.new
+      @core.stack = self # Set a back reference in the core.
+      @auto_reload = false
+      @app = false
+      @middleware = []
+      @recapture = true
+      @main_app = app_class
+      if block_given?
+        instance_eval(&block) 
+      else
+        @main_app = app_class.new(@core) unless app_class.nil? 
+        prebuild(prebuilt)
+      end
+    end
+    
+    # Runs methods necessary to build a stack. Don't use if a stack
+    # has already been built by the initialize block.
+    #
+    # @todo Offer more choices for default stacks
+    def prebuild(choice)
+      case choice
+      when :none
+        run @main_app
+      else
+        run @main_app
+      end
+    end
+    
+    # Returns the main application instance that was added by the 
+    # run method. Obviously won't return anything useful if the
+    # middleware stack hasn't been set up with an explicit exit point,
+    # as could be the case for a pure orange middleware stack on 
+    # top of a different exit application (like Sinatra or Rails)
+    def main_app
+      @main_app
+    end
+    
+    # Adds middleware using the Rack::Builder#use method
+    # @param [Object] middleware A class of middleware that meets rack middleware requirements
+    def use(middleware, *args, &block)
+      @build.use(middleware, *args, &block)
+    end
+    
+    # Loads resources into the core using the Orange::Core#load method
+    # 
+    # all args are passed on
+    def load(*args, &block)
+      orange.load(*args, &block)
+    end
+    
+    # Adds Orange-aware middleware using the Rack::Builder#use method, adding
+    # the orange core to the args passed on
+    def stack(middleware, *args, &block)
+      @build.use(middleware, @core, *args, &block)
+    end
+    
+    # Set the auto_reload option, called without args, defaults to true,
+    # other option is to set it to false
+    def auto_reload!(val = true)
+      @auto_reload = val
+    end
+    
+    # Shortcut for adding Orange::Middleware::ShowExceptions to the middleware
+    # stack
+    def use_exceptions
+      stack Orange::Middleware::ShowExceptions
+    end
+    
+    # Alias for use_exceptions
+    def show_exceptions
+      use_exceptions
+    end
+    
+    # Turn off recapture middleware, which is normally just on top of the exit
+    # point
+    # @see Orange::Middleware::Recapture
+    def no_recapture
+      @recapture = false
+    end
+    
+    # A shortcut for adding many of the routing middleware options
+    # simultaneously. Includes:
+    # * Orange::Middleware::Rerouter
+    # * Orange::Middleware::Static
+    # * Rack::AbstractFormat
+    # * Orange::Middleware::RouteSite
+    # * Orange::Middleware::RouteContext
+    # 
+    # All of these are passed the args hash to use as they will, except 
+    # for Rack::AbstractFormat
+    # 
+    def prerouting(*args)
+      opts = args.extract_options!
+      stack Orange::Middleware::Globals
+      stack Orange::Middleware::Loader
+      stack Orange::Middleware::Rerouter, opts.dup
+      stack Orange::Middleware::Static, opts.dup
+      use Rack::AbstractFormat unless opts[:no_abstract_format] 
+          # Must be used before non-destructive route altering done by Orange,
+          # since all orange stuff is non-destructive
+      stack Orange::Middleware::RouteSite, opts.dup
+      stack Orange::Middleware::RouteContext, opts.dup
+      stack Orange::Middleware::Database
+      Orange.plugins.each{|p| p.middleware(:prerouting).each{|m| stack m, opts.dup} if p.has_middleware?}
+    end
+    
+    # A shortcut for routing via Orange::Middleware::RestfulRouter and any plugins
+    #
+    # Any args are passed on to the middleware
+    def routing(opts ={})
+      stack Orange::Middleware::RestfulRouter, opts.dup
+      Orange.plugins.each{|p| p.middleware(:routing).each{|m| stack m, opts.dup} if p.has_middleware?}
+    end
+    
+    def postrouting(opts ={})
+      Orange.plugins.each{|p| p.middleware(:postrouting).each{|m| stack m, opts.dup} if p.has_middleware?}
+      stack Orange::Middleware::Template
+      stack Orange::Middleware::FourOhFour, opts.dup # Last ditch, send route to 404 page.
+    end
+    
+    def responders(opts ={})
+      Orange.plugins.each{|p| p.middleware(:responders).each{|m| stack m, opts.dup} if p.has_middleware?}
+    end
+    
+    # # A shortcut to enable Rack::OpenID and Orange::Middleware::AccessControl
+    #     # 
+    #     # Args will be passed on to Orange::Middleware::AccessControl
+    #     def openid_access_control(*args)
+    #       opts = args.extract_options!
+    #       
+    #     end
+    
+    # Adds pulp to the core via the Orange::Core#add_pulp method
+    # @param [Orange::Mixin] mod a mixin to be included in the packet
+    def add_pulp(mod)
+      orange.add_pulp(mod)
+    end
+    
+    # The exit point for the middleware stack,
+    # add the app to @main_app and then call Rack::Builder#run with the main app
+    def run(app, *args)
+      opts = args.extract_options!
+      @main_app = app
+      @build.run(app)
+    end
+    
+    # Returns the Orange::Core
+    # @return [Orange::Core] The orange core 
+    def orange
+      @core
+    end
+
+    # Passes through to Rack::Builder#map
+    # @todo Make this work - passing the block on to builder 
+    #   means we can't intercept anything, which will yield 
+    #   unexpected results
+    def map(path, &block)
+      raise 'not yet supported'
+      @build.map(path, &block)
+    end
+    
+    # Builds the middleware stack (or uses a cached one)
+    # 
+    # If auto_reload is enabled ({#auto_reload!}), builds every time
+    #
+    # @return [Object] a full stack of middleware and the exit application,
+    #   conforming to Rack guidelines
+    def app
+      if @auto_reload
+        orange.fire(:stack_reloading, @app) if orange.stack  # Alert we are rebuilding
+        @app = false                    # Rebuild no matter what if autoload
+      end
+      unless @app 
+        @app = do_build            # Build if necessary
+        orange.fire(:stack_loaded, @app)
+      end
+      @app
+    end
+    
+    def do_build
+      @build.to_app
+    end
+    
+    # Sets the core and then passes on to the stack, according to standard 
+    # rack procedure
+    def call(env)
+      env['orange.core'] = @core
+      app.call(env)
+    end
+    
+    # Debug helping
+    def inspect
+      "#<Orange::Stack:0x#{self.object_id.to_s(16)} @build=#{@build.inspect}, @core=#{@core.inspect}>"
+    end
+  end
+end