raw 0.49.0

data/lib/raw/compiler/filter/squeeze.rb

@@ -0,0 +1,16 @@
+module Raw
+
+# Compress HTML markup.
+ 
+class SqueezeFilter
+  
+  # Remove new lines. Typically used in live mode before the
+  # TemplateFilter.
+   
+  def apply(source)
+    source.gsub(/^(\s*)/m, "").gsub(/\n/, "").gsub(/\t/, " ").squeeze(" ")
+  end
+  
+end
+  
+end

data/lib/raw/compiler/filter/static_include.rb

@@ -0,0 +1,74 @@
+module Raw
+
+# Performs static includes. Typically you should include this 
+# compiler as the first stage of the compile pipeline.
+# 
+# This compiler is extremely helpful, typically you would want
+# to use static includes in many many cases.
+ 
+class StaticIncludeFilter
+
+  # Statically include sub-template files.
+  # The target file is included at compile time.
+  # If the given path is relative, the template_root stack of
+  # the controller is traversed. If an absolute path is provided,
+  # templates are searched only in Template.root
+  #
+  # gmosx: must be xformed before the <?r pi.
+  #
+  # === Example    
+  # <?include href="root/myfile.sx" ?>
+  
+  def apply(text)
+    resolve_include(text)    
+  end
+
+  def resolve_include_filename(href)
+    found = false
+
+    if href[0] == ?/
+      # Absolute path, search only in the application template
+      # root.
+
+      href = href[1, 999999] # hack!!
+      template_dir_stack = [ Template.root_dir ]
+    else
+      template_dir_stack = Controller.current.ann(:self, :template_dir_stack)
+    end
+      
+    for dir in template_dir_stack
+      if File.exist?(filename = "#{dir}/#{href}")
+        found = true
+        break
+      end
+
+      if File.exist?(filename = "#{dir}/#{href}.inc")
+        found = true
+        break
+      end
+    end
+    
+    raise "Cannot statically include '#{href}'" unless found
+
+    return filename
+  end
+
+  def resolve_include(text)
+    return text.gsub(/<\?include href=["|'](.*?)["|'](.*)\?>/) do |match|
+      filename = resolve_include_filename($1)
+
+      c = Context.current.application.compiler
+      c.templates = c.templates.push(filename).uniq       
+      itext = File.read(filename)
+      
+      itext.gsub!(/<\?xml.*\?>/, '')
+      
+      # Recursively resolve to handle sub-includes.
+      
+      resolve_include(itext)
+    end
+  end
+  
+end
+
+end

data/lib/raw/compiler/filter/template.rb

@@ -0,0 +1,121 @@
+module Raw
+
+# Nitro Template.
+
+class Template
+
+  # The default template dir.
+  
+  setting :root_dir, :default => File.expand_path("template"), :doc => "The default template dir"
+
+  # Strip xml comments from templates?
+  
+  setting :strip_xml_comments, :default => false, :doc => "Strip xml comments from templates?"
+
+end
+
+# The basic Nitro Template filter.
+
+class TemplateFilter
+
+  # Set some pretty safe delimiters for templates.
+
+  START_DELIM = "%{"
+  END_DELIM = "}\n"
+
+  # Convert a template to actual Ruby code, ready to be 
+  # evaluated.
+  #
+  # [+source+] 
+  #    The template source as a String.
+  #
+  # [+buffer+]
+  #    The variable to act as a buffer where the ruby code
+  #    for this template will be generated. Passed as a
+  #    String.
+  
+  def apply(source, buffer = "@out")
+    source = source.dup
+    
+    # Strip the xml header! (interracts with the following gsub!)
+
+    source.gsub!(/<\?xml.*\?>/, "")
+
+    # Transform include instructions <include href="xxx" />
+    # must be transformed before the processing instructions.
+    # Useful to include fragments cached on disk
+    #--
+    # gmosx, FIXME: NOT TESTED! test and add caching.
+    # add load_statically_included fixes.
+    #++
+    
+    source.gsub!(/<include\s+href=["'](.*?)["']\s+\/>/, %[<?r File.read("\#{@dispatcher.root}/\\1") ?>])
+    
+    # xform render/inject instructions <render href="xxx" />
+    # must be transformed before the processinc instructions.
+
+    source.gsub!(/<(?:render|inject)\s+href=["'](.*?)["']\s+\/>/, %[<?r render "\\1" ?>])
+
+    # Transform the processing instructions, use <?r as a marker.
+    
+    source.gsub!(/<\?r\s+(.*?)\s+\?>/m) do |code|
+      "#{END_DELIM}#{$1.squeeze(' ').chomp}\n#{buffer} << #{START_DELIM}"
+    end
+    
+    # Transform alternative code tags (very useful in xsl 
+    # stylesheets).
+
+    source.gsub!(/<ruby>(.*?)<\/ruby>/m) do |code|
+      "#{END_DELIM}#{$1.squeeze(' ').chomp}\n#{buffer} << #{START_DELIM}"
+    end
+    
+    # Also handle erb/asp/jsp style tags. Those tags *cannot* 
+    # be used with an xslt stylesheet.
+    #
+    # Example:
+    # 
+    # <% 10.times do %>
+    #   Hello<br />
+    # <% end %>
+
+    source.gsub!(/<%(.*?)%>/m) do |code|
+      "#{END_DELIM}#{$1.squeeze(' ').chomp}\n#{buffer} << #{START_DELIM}"
+    end
+
+    # Alterative versions of interpolation (very useful in xsl 
+    # stylesheets).
+    #
+    # Example: 
+    #
+    # Here is #\my_val\
+    
+    source.gsub!(/\#\\(.*?)\\/, '#{\1}')
+
+    # Alternative for entities (useful in xsl stylesheets).
+    #
+    # Examples:
+    #
+    # %nbsp;, %rquo;
+
+    source.gsub!(/%(#\d+|\w+);/, '&\1;')
+
+    # Compile time ruby code. This code is evaluated when
+    # compiling the template and the result injected directly
+    # into the result. Usefull for example to prevaluate
+    # localization. Just use the #[] marker instead of #{}.
+    #
+    # Example:
+    #
+    # This script was compiled at #[Time.now]
+    
+    source.gsub!(/\#\[(.*?)\]/) do |match|
+      eval($1)
+    end
+
+    return "#{buffer} << #{START_DELIM}#{source}#{END_DELIM}"
+  end
+
+
+end
+
+end

data/lib/raw/compiler/reloader.rb

@@ -0,0 +1,96 @@
+module Raw
+
+# Autoreload classes and templates. Mainly useful while 
+# debugging. Should be turned off in production servers to 
+# avoid the severe performance penalty.
+
+class Reloader
+    
+  def initialize(application)
+    @application = application
+    @mtimes = Hash.new(Time.now)
+  end  
+
+  # Start the monitor thread. This thread monitors code and
+  # template files.
+  #--
+  # gmosx: the thread accesses the reloader variables through the
+  # closure.
+  #++
+    
+  def start(interval)
+    @interval = interval
+    @thread = Thread.new do 
+      begin
+        loop do
+          sleep(@interval)
+
+          dirty = false          
+
+          # Check code files.
+          
+          for feature in $LOADED_FEATURES
+            for path in $LOAD_PATH
+              file = File.join(path, feature)
+              if File.exist?(file) and is_dirty?(file)
+                begin
+                  dirty = true
+                  load(feature)
+                rescue Exception => ex
+                  Logger.info ex.inspect
+                end
+              end
+            end
+          end
+
+          # Check template files.
+          
+          for template in @application.compiler.templates
+            if is_dirty? template
+              dirty = true
+              break
+            end
+          end
+          
+          reload_controllers() if dirty
+        end # loop
+      rescue => ex
+        Logger.info ex
+      end
+    end
+  end
+
+  #  Stop the monitor thread.
+  
+  def stop
+    @thread.exit
+  end
+  
+  # Is a file modified on disk?
+  
+  def is_dirty?(file)
+    if (mtime = File.stat(file).mtime) > @mtimes[file]
+      Logger.debug "File '#{file}' is modified" if $DBG
+      @mtimes[file] = mtime
+      return true
+    else
+      return false
+    end
+  end
+  
+  # When a template is modified, remove all generated methods
+  # from the controllers.
+  
+  def reload_controllers
+    controllers = @application.dispatcher.controllers.values
+    
+    for c in controllers
+      for m in c.instance_methods.grep(/(___control$)|(___view$)/)
+        c.send(:remove_method, m) rescue nil
+      end
+    end
+  end
+
+end
+
+end

data/lib/raw/context.rb

@@ -0,0 +1,154 @@
+require "facets/core/kernel/assign_with"
+
+require "raw/cgi"
+require "raw/context/request"
+require "raw/context/response"
+require "raw/context/global"
+require "raw/context/session"
+
+require "raw/util/attr"
+
+module Raw
+  
+# Encapsulates an HTTP processing cycle context. Integrates the 
+# HTTP Request and the HTTP Response with Session, Global and
+# Local variable stores.
+#
+# The Context object can be accessed by the context, request or 
+# response aliases. You can use the alias that makes sense 
+# every time. This means inside an action request, response and
+# context all point to the same object.
+
+class Context
+  include Request
+  include Response
+ 
+  # The application of this context. Contains configuration
+  # parameters.
+  
+  attr_accessor :application
+
+  # The session contains variables that stay alive 
+  # for the full user session. Session variables
+  # should be generally avoided. This variable
+  # becomes populated ONLY if needed.
+
+  attr_reader :session
+
+  # The rendering level. An action may include sub-actions,
+  # each time the action is called, the level is increased,
+  # when the action returns the level decreases. The first
+  # action, called top level action has a level of 1.
+  
+  attr_accessor :level
+
+  # The resource representation format for this request.
+  
+  attr_accessor :format
+
+  # The output buffer accumulates the generated output.
+  
+  attr_accessor :output_buffer
+
+  def initialize(application)
+    @level = 0
+    @application = application
+    @post_params = {}
+    @get_params = {}
+    @response_headers = {}
+    @output_buffer = ""
+    @status = Http::STATUS_OK
+
+    # Store this instance in a thread local variable for easy
+    # access.
+    
+    Thread.current[:CURRENT_CONTEXT] = self
+  end
+
+  # Don't sync session. This method may be needed in low level 
+  # hacks with the session code. For example if you updade an
+  # entity (managed) object that is cached in the session, you
+  # may dissable the syncing to avoid resetting the old value
+  # after the sync.
+  
+  def no_sync!
+    @no_sync = true
+  end
+  
+  # Close the context, should be called at the end of the HTTP 
+  # request handling code.
+
+  def close
+    if @session
+      # Ugly hack: need to use AOP instead
+      if @session.has_key?(:FLASH)
+        @session[:FLASH].clean
+      end
+      
+      # INVESTIGATE: is this needed?
+      @session.sync unless @no_sync
+    end
+  end
+  alias_method :finish, :close
+
+  # Access the dispactcher
+  
+  def dispatcher
+    @application.dispatcher
+  end
+
+  # Lazy lookup of the session to avoid costly cookie
+  # lookup when not needed.
+
+  def session
+    @session || @session = Session.lookup(self)
+  end
+
+  # Access global variables. In a distributed server scenario,
+  # these variables can reside outside of the process.
+  
+  def global
+    return Global
+  end
+
+  # Automagically populate an object from request parameters.
+  # This is a truly dangerous method.
+  #
+  # === Options
+  #
+  # * name
+  # * force_boolean
+  #
+  # === Example
+  #
+  # request.fill(User.new)
+  #
+  # This method is deprecated, Prefer to use the following form:
+  #
+  # User.new.assign_with(request)
+  
+  def fill(obj, options = {})
+    AttributeUtils.populate_object(obj, params, options)
+  end
+  alias_method :populate, :fill
+  alias_method :assign, :fill  
+  
+  # Is the current action the top level action? The level
+  # of the top action is 1.
+  
+  def is_top_level?
+    @level == 1
+  end
+  alias_method :top?, :is_top_level?
+  alias_method :is_top?, :is_top_level?
+  alias_method :top_level?, :is_top_level?
+
+  # Returns the context for the current thread.
+  
+  def self.current
+    Thread.current[:CURRENT_CONTEXT]
+  end
+    
+end
+
+end