raw 0.49.0

data/lib/raw/mixin/thumbnails.rb

@@ -0,0 +1 @@
+require "raw/mixin/magick"

data/lib/raw/mixin/webfile.rb

@@ -0,0 +1,165 @@
+require "fileutils"
+
+require "facets/more/inheritor"
+
+module Raw::Mixin
+
+# A Web File.
+#
+# You can customize the path where the uploaded file will be 
+# by defining a webfile_path class method *before* the property:
+#
+# class Icon
+#   def self.webfile_path request, name
+#     File.join(Uploads.public_root, request.user.name, 'icon.png')
+#   end      
+#
+#   attr_accessor :file, WebFile, :magick => { :small => '64x64', :medium => '96x96' }    
+# end
+#--
+# TODO: webfile_path customization sucks, should be improved!
+#++
+
+class WebFile
+
+  # The directory where uploaded files are stored. Typically 
+  # this is a symlink to another directory outside of the 
+  # webapp dir for easier updates.
+  
+  setting :upload_root, :default => 'upload', :doc => 'The directory where upload files are stored'
+  
+  # Override files by default?
+  
+  setting :override_files, :default => true, :doc => 'Override files by default?'
+
+  # Modify the base class when this class is included as a
+  # property
+  #--
+  # TODO: find a better name.
+  #++
+  
+  def self.included_as_property(base, args)
+    if args.last.is_a?(Hash)
+      options = args.pop
+    else
+      options = Hash.new
+    end
+    
+    args.pop if args.last.is_a?(Class)
+    
+    if thumbnails = (options[:thumbnail] || options[:thumbnails] || options[:magick]) or self.name == 'WebImage'
+      require 'glue/thumbnails'
+      base.send :include, Thumbnails
+      thumbnails = { :small => :thumbnails } if thumbnails.is_a?(String) 
+    end
+    
+    for name in args
+      base.module_eval do
+        # The 'web' path to the file (relative to the public
+        # root directory. Uses the original property name
+        # or the #{name}_path alias.
+                 
+        attr_accessor name.to_sym, String, :control => :file
+        alias_method "#{name}_path".to_sym, name.to_sym
+        
+        # The file size.
+        
+        attr_accessor "#{name}_size".to_sym, Fixnum, :control => :none
+        
+        # The mime type.
+
+        attr_accessor "#{name}_mime_type".to_sym, String , :control => :none
+     
+        # Assignment callbacks.        
+        #--
+        # gmosx, FIXME: this is a hack!! better implementation
+        # is needed (generalized property assigners).
+       
+        inheritor(:assign_callbacks, [], :merge) unless @assign_callbacks        
+      end
+
+      if thumbnails
+        for tname in thumbnails.keys
+          base.module_eval do
+            attr_accessor "#{name}_#{tname}_thumbnail".to_sym, String, :control => :none
+          end        
+        end
+      end
+
+      code = %{
+        def #{name}_real_path
+          File.join(Nitro::Server.public_root, @#{name})
+        end
+
+        def #{name}_from_request(request)
+          param = request['#{name}']
+          
+          return if param.nil? or param.original_filename.blank?
+      }
+      if base.respond_to? :webfile_path
+        code << %{
+          path = #{base}.webfile_path(request, '#{name}')
+        }
+      else
+        code << %{
+          path = File.join(WebFile.upload_root, WebFile.sanitize(param.original_filename))
+        }
+      end
+      
+      code << %{ 
+          @#{name} = path
+          @#{name}_size = param.size
+          
+          real_path = #{name}_real_path
+          raise 'file exists' if !WebFile.override_files and File.exists?(real_path)
+          FileUtils.mkdir_p(File.dirname(real_path))
+          if param.path
+            FileUtils.cp(param.path, real_path)
+          else
+            # gmosx FIXME: this is a hack!!
+            param.rewind
+            File.open(real_path, 'wb') { |f| f << param.read }
+          end
+          FileUtils.chmod(0664, real_path)
+      }
+
+      if thumbnails
+        for tname, geostring in thumbnails
+          code << %{
+            @#{name}_#{tname}_thumbnail = Thumbnails.generate_thumbnail(path, '#{tname}', '#{geostring}') 
+          }
+        end
+      end
+            
+      code << %{          
+        end
+        
+        def delete_#{name}
+          FileUtils.rm(#{name}_real_path)
+        end
+
+        assign_callbacks! << proc { |obj, values, options| 
+          obj.#{name}_from_request(values)
+        }
+      }
+      
+      base.module_eval(code)
+    end
+  end
+  
+  # Sanitize a filename. You can override this method to make 
+  # this suit your needs.
+  
+  def self.sanitize(filename)
+    ext = File::extname(filename)
+    base = File::basename(filename, ext).gsub(/[\\\/\? !@$\(\)]/, '-')[0..64]
+    return "#{base}.#{ext}"
+  end
+  
+end
+
+# An alias, implies thumbnailing.
+
+WebImage = WebFile
+
+end

data/lib/raw/render.rb

@@ -0,0 +1,271 @@
+require "stringio"
+
+require "facets/core/string/blank"
+require "facets/more/settings"
+
+require "raw/render/builder"
+require "raw/render/call"
+
+module Raw
+
+#--
+# Raise or Throw this exception to stop the current action.
+# Typically called to skip the template. This is considerered
+# a low level tactic. Prefer to use the exit method.
+#++
+
+class ActionExit < Exception # :nodoc: all
+end 
+  
+#--
+# Raise or Throw this exception to stop rendering altogether.
+# Typically called by redirects.
+#++
+
+class RenderExit < Exception # :nodoc: all
+end
+
+#--
+# The output buffer. The output of a contoller action is
+# accumulated in this buffer before sending this to the client
+# as a HTTP Response.
+#
+# TODO: Implement a FAST string (maybe in C)
+#++
+
+class OutputBuffer < String # :nodoc: all
+end
+
+# The rendering mixin. This module is typically included in
+# published objects and/or controllers to provide rendering
+# functionality.
+
+module Render
+
+  # The output buffer. The output of a script/action is 
+  # accumulated in this buffer.
+  
+  attr_accessor :out  
+  alias_method :body, :out
+    
+  # The context.
+  
+  attr_accessor :context
+  alias_method :request, :context
+  alias_method :response, :context
+    
+  # The name of the currently executing action.
+
+  attr_accessor :action_name
+
+  # The current controller class.
+  
+  attr_accessor :controller
+  
+  # Initialize the render.
+  #
+  # [+context+]
+  #    A parent render/controller acts as the context.
+
+  def initialize(context)
+    @context = context
+    @out = context.output_buffer
+  end
+
+  # Renders the action denoted by path. The path
+  # is resolved by the dispatcher to get the correct
+  # controller.
+  #
+  # Both relative and absolute paths are supported. Relative
+  # paths are converted to absolute by prepending the mount path
+  # of the controller.
+  
+  def render(*args)
+    path = encode_uri(*args)
+    debug "Rendering '#{path}'" if $DBG
+  
+    @controller, action, query, params, ext = @context.dispatcher.dispatch(path)
+    @context.content_type = @context.format.content_type
+
+    @context.level += 1
+    old_controller = Controller.replace_current(@controller)
+    
+    if self.class == @controller 
+      self.send(action, params)
+    else
+      @controller.new(@context).send(action, params)
+    end
+
+    Controller.replace_current(old_controller)
+    @context.level -= 1
+
+  rescue RenderExit, ActionExit => e1
+    # Just stop rendering.     
+    
+  rescue ActionError => e2
+    # Client Error family of errors, typically send 4XX
+    # status code.
+    handle_error(e2, 404)
+    error e2.to_s
+        
+  rescue Object => e3
+    # Server Error family of errors, typically send 5XX
+    # status code.
+    # puts "--------", pp_exception(e3)
+    
+    handle_error(e3, 500)
+    error "Error while handling '#{path}'"
+    error pp_exception(e3)
+  end
+
+private
+  RADIUS = 3
+
+  # Extract the offending source code for a server error.
+  
+  def extract_source_from(error)
+    extract = []
+    
+    code = error.backtrace[1]
+    md = code.match(%r{:(\d+):in `(.*)'$})
+    line_num = md[1].to_i
+    
+    code.split("\n")[(line_num - RADIUS)..(line_num + RADIUS)].each_with_index do |line, idx|
+      lidx = line_num - RADIUS + idx 
+      extract << "#{lidx}: #{line}"
+    end    
+    
+    return extract
+  end
+
+  # Helper method to exit the current action, typically used
+  # to skip the template rendering.
+  # 
+  # === Example
+  #
+  # def my_action
+  #   ...
+  #   exit unless user.admin?
+  # end
+  
+  def exit
+    raise ActionExit.new
+  end
+
+  # Flush the IO object (OutputBuffer) if we are in streaming 
+  # mode.
+  
+  def flush
+    @out.flush if @out.is_a?(IO)
+  end
+
+  # :section: Redirection methods.
+
+  # Send a redirect response.
+  #
+  # If the URI (path) starts with '/' it is considered absolute, else
+  # the URI is considered relative to the current controller and
+  # the controller base is prepended.
+  #
+  # The parameters are passed to the R operator (encode_uri)
+  # to actually build the URI. So the following forms (among
+  # others) are allowed:
+  #
+  # redirect 'home/login'
+  # redirect ForaController, :post, :title, 'The title'
+  # redirect :welcome
+  # redirect article # => article.to_href
+  #
+  # You can also pass optional hash parameters at the end,
+  # for example:
+  #
+  # redirect :welcome, :status => 307
+  #
+  # The default redirect status is 303.
+  #
+  #--
+  # TODO: add a check for redirect to self (infinite loop)
+  #++
+  
+  def redirect(*args)
+    # If this is an ajax  and/or rpc request skip the redirect.
+    # Allows to write more reusable  code.
+
+    return if  request.script?
+  
+    if args.last.is_a? Hash
+      status = args.last.fetch(:status, 303)
+    else
+      status = 303
+    end
+
+    uri = encode_uri(*args)
+
+    # gmosx, THINK: this may be unnecessary!
+
+    unless uri =~ /^http/
+      uri = "#{@context.host_uri}/#{uri.gsub(/^\//, '')}"
+    end
+
+    @context.status = status
+    @out = "<html><a href=\"#{uri}\">#{uri}</a>.</html>\n"
+    @context.response_headers['location'] = uri
+
+    raise RenderExit
+  end
+  alias_method :redirect_to, :redirect
+  
+  # Redirect to the referer.
+  
+  def redirect_referer(postfix = nil, status = 303)
+    redirect "#{@context.referer}#{postfix}", :status => status
+  end
+  alias_method :redirect_to_referer, :redirect_referer
+  alias_method :redirect_referrer, :redirect_referer
+  alias_method :redirect_to_referrer, :redirect_referer
+
+  # Redirect to home.
+  
+  def redirect_home(status = 303)
+    redirect "/", :status => status
+  end
+  alias_method :redirect_to_home, :redirect_home
+
+  # Handle an error.
+  #--
+  # gmosx, TODO: add check for infinite loops here.
+  #++
+   
+  def handle_error(exception, error_status = 500)
+    @context.status = error_status
+    @out = ""
+    
+    session[:RENDERING_ERROR] = exception
+
+    render("/status_#{error_status}")
+  end
+
+  # Convenience method to lookup the session.
+
+  def session
+    @context.session
+  end
+  
+  # Add some text to the output buffer.
+
+  def render_text(text)
+    @out << text
+  end
+  alias_method :print, :render_text
+
+  # Render a template into the output buffer.
+  # HACK FIX, will be removed.
+  
+  def render_template(path)
+    render(path)
+    exit
+  end
+
+end
+
+end

data/lib/raw/render/builder.rb

@@ -0,0 +1,26 @@
+require "glue/builder/xml"
+
+module Raw
+
+module Render
+
+  # Access the programmatic renderer (builder).
+  
+  def build(&block)
+    if block.arity == 1
+      yield XmlBuilder.new(@out)
+    else
+      XmlBuilder.new(@out).instance_eval(&block)
+    end
+  end
+
+  # Return a programmatic renderer that targets the
+  # output buffer.
+  
+  def builder
+    XmlBuilder.new(@out)
+  end
+
+end
+
+end