raw 0.49.0

data/lib/raw/render/caching.rb

@@ -0,0 +1,81 @@
+require "fileutils"
+
+require "facets/more/settings"
+require "facets/core/file/self/write"
+require "facets/core/kernel/eigenclass"
+
+module Raw
+
+# Add output caching to the Render.
+
+module Caching
+
+  # Enable or disable view caching.
+  
+  setting :enabled, :default => true, :doc => "Enable view caching"
+
+private
+
+  # Cache the output (view) of the current action.
+    
+  def cache_output
+    return unless (caching_enabled? and caching_allowed?)
+
+    if self.class.ann(@action, :cache) # or self.class.ann(:self, :cache)
+      path = File.join(@context.application.public_dir, @context.path)
+      FileUtils.makedirs(File.dirname(path))
+      Logger.debug "Caching '#{path}'" if $DBG
+      File.write(path, @out) 
+    end    
+  rescue => ex
+    Logger.error ex.to_s
+  end
+
+  # Explicitly expire the given cached file. If the filename has
+  # no  extension attach .* to  expire the cached files for
+  # all format representations.
+  #--
+  # TODO: use encode_uri
+  #++
+  
+  def expire_output(*args)
+    path = encode_uri(*args)
+    
+    if File.extname(path).blank?
+      # Clear all cached representations.
+      if path =~ %r{/$}
+        path << "index.*"
+      else
+        path << ".*"
+      end
+    end
+    
+    path = File.join(Context.current.application.public_dir, path)
+    
+    Logger.debug "Expiring cache files '#{path}'" if $DBG
+    FileUtils.rm_rf(path)
+  rescue => ex
+    # drink it!
+  end
+  alias_method :delete_output, :expire_output
+
+  # Enable or disable caching. Can be overriden per controller
+  # for extra fine grained caching control.
+  
+  def caching_enabled?
+    Caching.enabled
+  end  
+
+  # Is caching allowed for this action (page)? The default
+  # implementation does not cache post request or request 
+  # with query parameters. You can work arround the second
+  # 'limitation' by cleverly using Nitro's implicit support
+  # for 'nice' URIs.
+  
+  def caching_allowed?
+    not (@context.post? or @context.uri =~ /\?/)
+  end
+  
+end
+
+end

data/lib/raw/render/call.rb

@@ -0,0 +1,43 @@
+module Raw
+
+#--
+# Seaside style call/answer methods.
+#++
+  
+module Render
+
+  # Call redirects to the given URI but push the original
+  # URI in a callstack, so that the target can return by 
+  # executing answer.
+  #
+  #--
+  # FIXME: dont use yet, you have to encode the branch to 
+  # make this safe for use.
+  #++
+  
+  def call(*args)
+    (session[:CALL_STACK] ||= []).push(request.uri)
+    redirect(*args)
+  end
+  
+  # Returns from a call by poping the callstack.
+  # Use force = false to make this mechanism more flexible.
+  #--
+  # FIXME: don't use yet.
+  #++
+    
+  def answer(force = false, status = 303)
+    if stack = session[:CALL_STACK] and not stack.empty?
+      redirect(stack.pop, :status => status)
+    else
+      if force
+        raise 'Cannot answer, call stack is empty'
+      else
+        redirect_to_home
+      end
+    end
+  end
+
+end
+
+end

data/lib/raw/render/send_file.rb

@@ -0,0 +1,46 @@
+require "raw/render"
+
+module Raw
+
+module Render
+
+  # Send a file download to the client.
+  #
+  # Like render and redirect, the action is exited upon calling
+  #
+  # [+fname+]  That name of the file
+  # [+path+]   Specifying true mean fname contains the full path.
+  #     The default, false, uses Server.public_root as the path.
+  #
+  # [+return+] true on success, false on failure
+  #
+  # === Examples
+  #
+  # require "raw/render/send_file"
+  #
+  # class MyController < Nitro:Controller
+  #   def download(fname)
+  #     send_file(fname)
+  #   end
+  # end
+  #
+  # class MyController < Nitro:Controller
+  #   def download
+  #     send_file("/etc/password", true)
+  #   end
+  # end
+  
+  def send_file(fname = nil, fullpath = false)
+    fname = fullpath ? fname : "#{@context.application.public_dir}/#{fname}"
+    f = File.open(fname, "rb")
+    @context.response_headers["Cache-control"] = "private"
+    @context.response_headers["Content-Length"] = "#{File.size?(f) || 0}"
+    @context.response_headers["Content-Type"] = "application/force-download"
+    @context.output_buffer = f
+    raise RenderExit
+  end
+  alias_method :sendfile, :send_file
+
+end
+
+end

data/lib/raw/render/stream.rb

@@ -0,0 +1,39 @@
+require "raw/render"
+
+module Raw
+
+module Render
+
+  # Enable streaming mode for the current HTTP Response.
+  # You can optionally provide an existing IO object for 
+  # streaming.
+  #--
+  # This code is considered a hack fix. But it still is useful 
+  # so for the moment it stays in the distribution.
+  #++
+  
+  def stream(io = nil)
+    if io
+      # Reuse an existing IO if it exists.
+      @context.output_buffer = io
+    else  
+      r, w = IO.pipe
+      
+      @context.output_buffer = r
+      @out = w
+      r.sync = true    
+      w.class.send(:define_method, :empty?) { false }
+  
+      Thread.new do 
+        begin
+          yield
+        ensure
+          w.close
+        end
+      end
+    end
+  end
+  
+end
+
+end

data/lib/raw/scaffold.rb

@@ -0,0 +1,13 @@
+module Raw
+
+# Scaffolding is one facet of Nitro's Rapid Application 
+# Develpoment (RAD) features. The scaffolder automatically 
+# generates common code for managed object and their 
+# controllers.
+
+module Scaffold
+end
+
+require "raw/scaffold/model"
+
+end

data/lib/raw/scaffold/controller.rb

@@ -0,0 +1,25 @@
+module Raw
+
+module Scaffold
+
+  # Automatically creates a scaffold controller to handle the
+  # given models.
+  
+  def self.controller(*models)
+    for m in models
+      scaffold_controller(m)
+    end
+  end
+  
+  def self.enchant_controller(model)
+    eval %{
+    
+    }  
+  end
+
+end
+
+class Controller
+end
+
+end

data/lib/raw/scaffold/model.rb

@@ -0,0 +1,157 @@
+module Raw
+
+# Scaffolding is one facet of Nitro's Rapid Application 
+# Develpoment (RAD) features. The scaffolder automatically 
+# generates common code for managed object and their 
+# controllers.
+
+module Scaffold
+
+  # Automatically enchant all models ?
+  
+  setting :enchant_all_models, :default => false, :doc => 'Automatically enchant all models?'
+
+  # Enchant all models.
+  
+  def self.all_models
+    if Scaffold.enchant_all_models
+      self.model(*Og.manager.managed_classes)
+    end
+  end
+
+  # 'Enchant' a model class (typically a managed class, 
+  # entity). A collection of useful methods are magically 
+  # added to the class and/or the class instances.
+  #
+  # * to_s
+  # * to_href
+  # * to_link
+  # * to_edit_href
+  # * to_admin_href
+  #--
+  # to_xxx is used instead of xxx in an attempt to avoid 
+  # colisions with user defined methods.
+  #++
+  
+  def self.model(*classes)
+    for c in classes
+      enchant_model c
+    end
+  end
+  
+  #--
+  # Actually enchant the given class. Override this method
+  # to customize for your application. The string calculation
+  # code is deliberatly dynamic to work with Ruby's OO 
+  # features.
+  #++
+  
+  def self.enchant_model(klass)
+    # Find the controller that handles this model. Unless no
+    # controller annotation is defined, try to find a controller
+    # of the form: Model::Controller. Some examples:
+    #
+    # class Ticket
+    #   ann :self, :controller => SpecialTicketController
+    #   ..
+    # end
+    #
+    # or try to find a Ticket::Controller class. 
+
+    controller = klass.ann(:self, :controller) || klass.constant('Controller')
+
+    # If the class defines a text_key use it to create more
+    # readable (and SEO friendly) URIs.
+    
+    key = klass.ann(:self, :text_key) || 'oid' 
+
+    # to_s
+          
+    if klass.instance_methods.include? 'title'
+      define_instance_method klass, :to_s, %{ title }, force = true      
+    elsif klass.instance_methods.include? 'name'
+      define_instance_method klass, :to_s, %{ name }, force = true      
+    end
+  
+    # to_href
+    # ex: /articles/23
+
+    define_instance_method klass, :to_href, %{
+      "\#{#{controller}.mount_path}/read/\#{#{key}}".squeeze('/')
+    }
+
+    # to_link
+    # ex: <a href="/articles/23">The article's title</a>
+    
+    define_instance_method klass, :to_link, %{
+      %|<a href="\#{to_href}">\#{to_s}</a>|
+    }
+
+    # to_link
+    # ex: <a href="/articles/23">The article's title</a>
+    
+    define_class_method klass, :controller, %{
+      #{controller}
+    }
+                  
+    if defined? OgAdminController
+      self.extend(OgAdminHelper)
+
+      # to_edit_href
+      # ex: admin/update/Article/23
+
+      define_instance_method klass, :to_edit_href, %{
+        "\#{OgAdminController.mount_path}/update/#{class_to_name(klass)}/\#{oid}"
+      }
+
+      # to_admin_href
+      # ex: admin/list/Article
+
+      define_instance_method klass, :to_admin_href, %{
+        "\#{AdminController.mount_path}/list/#{class_to_name(klass)}"
+      }
+                    
+      # to_admin_href
+      # ex: admin/list/Article
+
+      define_class_method klass, :to_admin_href, %{
+        "\#{AdminController.mount_path}/list/#{class_to_name(klass)}"
+      }
+    end
+  end
+
+  #--
+  # This helper defines an instance method for the 
+  # scaffolded class. The method is only defined if the klass
+  # does not already respond to it.
+  #++
+  
+  def self.define_instance_method(klass, meth, body, force = false)
+    if force or (!klass.instance_methods.include? meth.to_s)
+      klass.module_eval %{
+        def #{meth}
+          #{body}
+        end
+      }
+    end
+  end
+
+  #--
+  # This helper defines an class method for the 
+  # scaffolded class. The method is only defined if the klass
+  # does not already respond to it.
+  #++
+  
+  def self.define_class_method(klass, meth, body, force = false)
+    if force or (!klass.respond_to? meth.to_s)
+      klass.module_eval %{
+        def self.#{meth}
+          #{body}
+        end
+      }
+    end
+  end
+    
+end
+
+end

data/lib/raw/test.rb

@@ -0,0 +1,5 @@
+$NITRO_NO_ENVIRONMENT = true
+$NITRO_NO_INVOKE = true
+
+require 'nitro/test/assertions'
+require 'nitro/test/testcase'

data/lib/raw/test/assertions.rb

@@ -0,0 +1,169 @@
+require 'test/unit'
+require 'test/unit/assertions'
+require 'rexml/document'
+
+module Test::Unit::Assertions
+
+  STATUS_MAP = {
+    :success => 200,
+    :ok => 200,
+    :redirect => 307
+  }
+  
+  # :section: General assertions.
+
+  # Check the status of the response.
+  
+  def assert_response(options = {})
+    unless options.is_a? Hash
+      options = { :status => options }
+    end
+    msg = options[:msg]
+    if status = options.fetch(:status, :success)
+      status = STATUS_MAP[status] if STATUS_MAP.has_key?(status)
+      assert_status(status, msg)
+    end
+  end
+
+  def assert_status(status, msg)
+    msg = format_msg("Status not '#{status}'", msg)
+    assert_block(msg) { @context.status == status }
+  end
+    
+  #--
+  # Compile some helpers.
+  #++
+  
+  for m in [:get, :post, :put, :delete, :head]
+    eval %{
+      def assert_#{m}(uri, headers = {}, params = {}, session = nil)
+        #{m}(uri, headers, params, session)
+        assert_response :success
+      end 
+    }
+  end
+  
+  def assert_output(options = {})
+    msg = options[:msg]
+    if re = options[:match] || options[:contains]
+      assert_output_match(re, msg)
+    end
+    if re = options[:no_match] || options[:contains_no]
+      assert_output_not_match(re, msg)
+    end
+    if content_type = options[:content_type]
+      assert_content_type(content_type, msg)
+    end
+  end
+  
+  def assert_output_match(re, msg)
+    msg = format_msg("Rendered output does not match '#{re.source}'", msg)
+    assert_block(msg) { @context.body =~ Regexp.new(re) }
+  end
+  alias_method :assert_output_contains, :assert_output_match
+
+  def assert_output_not_match(re, msg)
+    msg = format_msg("Rendered output matches '#{re.source}'", msg)
+    assert_block(msg) { @context.out =~ Regexp.new(re) }
+  end
+  alias_method :assert_output_contains_not, :assert_output_match
+
+  def assert_content_type(ctype, msg)
+    msg = format_msg("Content type is not '#{ctype}' as expected", msg)
+    assert_block(msg) { @context.content_type == ctype }
+  end    
+  
+  # :section: Session related assertions.
+
+  def assert_session(options = {})
+    msg = options[:msg]
+    if key = options[:has]
+      assert_session_has(key, msg)
+    end
+    if key = options[:has_no] || options[:no]
+      assert_session_has_no(key, msg)
+    end
+    if key = options[:key] and value = options[:value]
+      assert_session_equal(key, value, msg)
+    end    
+  end
+
+  def assert_session_has(key, msg = nil)
+    msg = format_msg("Object '#{key}' not found in session", msg)
+    assert_block(msg) {  @context.session[key] }
+  end
+
+  def assert_session_has_no(key, msg = nil)
+    msg = format_msg("Unexpected object '#{key}' found in session", msg)
+    assert_block(msg) { !@context.session[key] }
+  end
+  
+  def assert_session_equal(key, value, msg = nil)
+    msg = format_msg("The value of session object '#{key}' is '#{@context.session[key]}' but was expected '#{value}'", msg)
+    assert_block(msg) { @context.session[key] == value }
+  end
+
+  # :section: Cookies related assertions.
+
+  def assert_cookie(options = {})
+    msg = options[:msg]
+    if key = options[:has]
+      assert_cookie_has(key, msg)
+    end
+    if key = options[:has_no] || options[:no]
+      assert_cookie_has_no(key, msg)
+    end
+    if key = options[:key] and value = options[:value]
+      assert_cookie_equal(key, value, msg)
+    end    
+  end
+
+  def assert_cookie_has(name, msg = nil)
+    msg = format_msg("Cookie '#{name}' not found", msg)
+    assert_block(msg) { @context.response_cookie(name) }
+  end
+
+  def assert_cookie_has_no(name, msg = nil)
+    msg = format_msg("Unexpected cookie '#{name}' found", msg)
+    assert_block(msg) { !@context.response_cookie(name) }
+  end
+  
+  def assert_cookie_equal(name, value, msg = nil)
+    unless cookie = @context.response_cookie(name)
+      msg = format_msg("Cookie '#{name}' not found", msg)
+      assert_block(msg) { false }
+    end
+    msg = format_msg("The value of cookie '#{name}' is '#{cookie.value}' but was expected '#{value}'", msg)
+    assert_block(msg) { cookie.value == value }
+  end
+
+  # :section: Nitro::Template related assertions.
+  
+  # :section: Redirection assertions.
+
+  def assert_redirected(options = {})
+    msg = options[:msg]
+    
+    msg = format_msg("No redirection (status = #{@context.status})", msg)
+    assert_block(msg) { @context.redirect? }
+    
+    if to = options[:to]
+      msg = format_msg("Not redirected to '#{to}'", msg)
+      assert_block(msg) { @context.response_headers['location'] == "http://#{to}" }
+    end
+  end
+
+  def assert_not_redirected(options = {})
+    msg = options[:msg]
+    msg = format_msg("Unexpected redirection (location = '#{@context.response_headers['location']}')", msg)
+    assert_block(msg) { !@context.redirect? }
+  end
+  
+  # :section: Utility methods 
+
+  def format_msg(message, extra) # :nodoc:
+    extra += ', ' if extra
+    return "#{extra}#{message}"
+  end
+
+end