nitro 0.20.0 → 0.21.0

data/lib/nitro/compiler/errors.rb

@@ -0,0 +1,65 @@
+require 'facet/string/demodulize'
+
+module Nitro
+
+class ActionCompileError < SyntaxError
+  SOURCE_CODE_RADIUS = 5
+
+  attr_accessor :original_excpetion
+    
+  def initialize(source_code, filename, original_exception)
+    @source_code = source_code.split("\n")
+    @filename = filename
+    @original_exception = original_exception
+  end
+  
+  def line_number
+    trace = @original_exception.backtrace.join
+
+    if trace.include?(":in `class_eval'")
+      trace.scan(/:([0-9]*):in `class_eval'/).first.first.to_i
+    else
+      1
+    end
+  end
+  
+  def source_extract(indent = 0)
+    ln = line_number
+    start_line = [ln - SOURCE_CODE_RADIUS, 0].max
+    end_line = [ln + SOURCE_CODE_RADIUS - 1, @source_code.length].min
+
+    number = start_line
+    extract = @source_code[start_line..end_line].collect do |line| 
+      number += 1
+      line = line.gsub(/; @out << %\^/, ' ?>').gsub(/\^;/, '<?r ')
+      if number == line_number
+        "#{' ' * indent}#{number}: #{line}"
+      else
+        "#{' ' * indent}#{number}: #{line}"
+      end
+    end
+
+    return extract.join("\n")
+  end
+
+  def backtrace  
+    @original_exception.backtrace.collect do |line|
+      line.gsub("#{Nitro::LibPath}/", '')
+    end.compact
+  end
+
+  def to_s
+    "#{self.class.to_s.demodulize} (#{@original_exception.class}): '#@filename' at line ##{line_number}"
+  end
+  
+  def message
+    "#{to_s}\n#{source_extract}"
+  end
+end
+  
+class TemplateCompileError < ActionCompileError
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/nitro/compiler/localization.rb

@@ -0,0 +1,25 @@
+require 'glue/localization'
+
+module Glue
+
+class Localization
+
+  class << self
+
+    # Transform localization macros.
+    
+    def transform(text)
+      # handle symbols
+      text.gsub!(/\[\[\:(.*?)\]\]/, '#{@lc[\1]}')
+
+      # handle strings 
+      text.gsub!(/\[\[(.*?)\]\]/, '#{@lc["\1"]}')
+
+      return text
+    end
+
+  end
+
+end
+
+end

data/lib/nitro/compiler/markup.rb

@@ -0,0 +1,19 @@
+require 'nitro/mixin/markup'
+
+module Nitro
+
+module Markup
+
+  # Transform the markup macros.
+  # Maps #(..) to :sanitize.
+  # Maps #|..| to :markup.
+  
+  def self.transform(text)
+    text.gsub!(/\#\((.*?)\)/, '#{sanitize(\1)}')
+    text.gsub!(/\#\|(.*?)\|/, '#{markup(\1)}')
+    return text
+  end
+  
+end
+
+end

data/lib/nitro/compiler/shaders.rb

@@ -0,0 +1,206 @@
+require 'nitro/template'
+require 'nitro/element'
+
+module Nitro
+
+# A shader defines a transformation-pipeline that tansforms 
+# the .xhtml files to actual ruby code ready for evaluation 
+# (compilation) by the engine.
+#
+# Shaders employ a folded-filter design.
+#--
+# TODO: pipeline stage mixin to be reused in filters too.
+#++
+
+class Shader
+  
+  # the next stage in the Shader pipeline.
+  
+  attr :next_stage
+  
+  def initialize(next_stage = nil)
+    @next_stage = next_stage
+  end
+  
+  # Process the text and optionally update the hash.
+  # The hash is a short, unique representation of the 
+  # input text, typically used as a caching key.
+  
+  def process(hash, text)
+    process_next(hash, text)
+  end
+
+  # Set the next stage of the pipeline.
+  
+  def << (next_stage = nil)
+    @next_stage = next_stage
+    return self
+  end
+  
+  # Process the next stage of the pipeline.
+  
+  def process_next(hash, text)
+    if @next_stage
+      return @next_stage.process(hash, text)
+    else
+      return hash, text
+    end
+  end  
+end
+
+# Convert the xhtml script to actual Ruby code, ready 
+# to be evaluated.
+
+class RubyShader < Shader
+  include TemplateMixin
+
+  # Convert the xhtml script to actual Ruby code, ready 
+  # to be evaluated.
+  #--
+  # Investigate:
+  # perhaps xl:href should be used to be XLink compatible?
+  #++
+  
+  def process(hash, text)
+    text = compile_template(text) 
+    process_next(hash, text)
+  end
+
+  # Loads and statically includes a file.
+  
+  def load_statically_included(filename)
+    Logger.debug "Statically including '#{filename}'" if $DBG
+    
+    text = File.read(filename)
+    text.gsub!(/<\?xml.*\?>/, '')
+    text.gsub!(/<\/?root(.*?)>/m, ' ');
+    
+    return text
+  end
+  
+end
+
+# Apply an XSL transformation to the script code.
+# There is no need to keep post xsl. I can reuse the 
+# same xsl by calling transform again. 
+
+class XSLTShader < Shader
+  
+  # The name
+  
+  attr :name
+  
+  # The xslt filename.
+  
+  attr :xsl_filename
+  
+  # The xslt transformer.
+  
+  attr :xslt
+  
+  # Last modified time of the xslt.
+  
+  attr :mtime
+  
+  def initialize(xsl_filename, next_stage = nil)
+
+    # leave this require here. only inlcude the xslt 
+    # library if the project needs it.
+    
+    require "xml/xslt"
+
+    @name = File.basename(xsl_filename, '.*')
+    @xsl_filename = xsl_filename
+    @xslt = XML::XSLT.new
+    @next_stage = next_stage
+  end
+  
+  # Transform the given text.
+  
+  def process(hash, text)
+    parse_xsl()
+    @xslt.xml = text
+    hash += @name
+    Logger.debug "Applying xsl '#{@xsl_filename}' to template" if $DBG
+    process_next(hash, xslt.serve)
+  end
+  
+  private 
+  
+  # Parse the xsl.
+  
+  def parse_xsl
+    Logger.debug "Parsing xsl '#{@xsl_filename}'" if $DBG
+    @mtime = File.mtime(@xsl_filename)
+    @xslt.xsl = File.read(@xsl_filename)
+  end
+
+end
+
+# Compress the inline xhtml. Does not touch the ruby code.
+ 
+class CompressShader < Shader
+  
+  # Compress the inline xhtml. Does not touch the ruby code.
+   
+  def process(hash, text)
+    text.gsub!(/\@out \<\< \%\^(.*?)\^/m) do |match|
+      c = $1.gsub(/^(\s*)/m, '').squeeze(" \t").tr("\n", '').tr("\t", ' ')
+      "@out << %{#{c}}"
+    end
+    
+    process_next(hash, text)
+  end
+  
+end
+
+# MorphingShader
+
+class MorphingShader < Shader
+
+  def process(hash, text)
+
+    # <tag if="x">..</tag>
+    # <tag unless="x">..</tag>
+
+    text.gsub!(/<(\w*?)([^>]*?)(if|unless)=["|'](.*?)["|'](.*?)>(.*?)<\/\1>/m) do |match|
+      %{<?r #$3 #$4 ?>
+        <#$1#$2#$5>#$6</#$1>
+      <?r end ?>}
+    end
+
+    # <tag times="x">..</tag>
+
+    text.gsub!(/<(\w*?)([^>]*?)times=["|'](.*?)["|'](.*?)>(.*?)<\/\1>/m) do |match|
+      %{<?r #$3.times do ?>
+        <#$1#$2#$4>#$5</#$1>
+      <?r end ?>}
+    end
+
+    # <tag each="x">..</tag>
+
+    text.gsub!(/<(\w*?)([^>]*?)each=["|'](.*?)["|'](.*?)>(.*?)<\/\1>/m) do |match|
+      %{<?r for #$3 ?>
+        <#$1#$2#$4>#$5</#$1>
+      <?r end ?>}
+    end
+    
+    process_next(hash, text)
+  end
+
+end
+
+# ElementsShader
+
+class ElementsShader < Shader
+
+  def process(hash, text)
+    text = ElementProcessor.render(text)
+    process_next(hash, text)
+  end
+  
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/nitro/compiler/squeeze.rb

@@ -0,0 +1,20 @@
+module Nitro::Compiler
+  
+# Compress the inline xhtml. Does not touch the ruby code.
+ 
+class Squeeze
+  
+  # Compresses the inline xhtml. Does not touch the ruby code.
+   
+  def transform(text)
+    return text.gsub(/\@out \<\< \%\^(.*?)\^/m) do |match|
+      c = $1.gsub(/^(\s*)/m, '').squeeze(" \t").tr("\n", '').tr("\t", ' ')
+      "@out << %{#{c}}"
+    end
+  end
+  
+end
+  
+end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/nitro/compiler/xslt.rb

@@ -0,0 +1,61 @@
+require 'sync'
+
+require 'xml/xslt'
+
+module Nitro
+
+# Apply XSL transformation.
+
+class XSLTransform
+    @@sync = Sync.new
+
+  class << self
+
+    # The xslt filename.
+    
+    attr :xsl_filename
+    
+    # The xslt transformer.
+    
+    attr :xslt
+  
+    def initialize(xsl_filename, next_stage = nil)
+
+      # leave this require here. only inlcude the xslt 
+      # library if the project needs it.
+      
+      require "xml/xslt"
+
+      @name = File.basename(xsl_filename, '.*')
+      @xsl_filename = xsl_filename
+      @xslt = XML::XSLT.new
+      @next_stage = next_stage
+    end
+    
+    # Transform the given xml.
+    
+    def transform(text)
+      
+      parse_xsl()
+      @xslt.xml = text
+      hash += @name
+      Logger.debug "Applying xsl '#{@xsl_filename}' to template" if $DBG
+      process_next(hash, xslt.serve)
+    end
+    
+    private 
+    
+    # Parse the xsl.
+    
+    def parse_xsl
+      Logger.debug "Parsing xsl '#{@xsl_filename}'" if $DBG
+      @mtime = File.mtime(@xsl_filename)
+      @xslt.xsl = File.read(@xsl_filename)
+    end  
+  end
+  
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/nitro/context.rb

@@ -2,101 +2,100 @@ require 'nitro/request'
 require 'nitro/response'
 require 'nitro/render'
 require 'nitro/session'
-require 'nitro/output'
 require 'nitro/adapter/cgi.rb'
 
 module Nitro
-	
+  
 # Encapsulates an HTTP processing cycle context.
 # Integrates the Request and the Response.
 
 class Context
-	include Request
-	include Response
-	include Render
-
-	# The configuration parameters.
-
-	attr_accessor :conf
-
-	# 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 dispatcher.
-
-	attr_accessor :dispatcher
-
-	def initialize(conf)
-		@conf = conf
-		@dispatcher = @conf.dispatcher
-		@context = self
-
-		# initialize response.
-		
-		@status = CgiUtils::STATUS_OK
-		@response_headers = { 'Content-Type' => 'text/html' }
-
-		# initialize the output buffer.
-
-		@out = OutputBuffer.new
-	end
-
-	# Close the context, should be called at the 
-	# end of the HTTP request handling code.
-
-	def close
-		@session.sync if @session
-	end
-	alias_method :finish, :close
-
-	#--
-	# FIXME: something more elegant/efficient.
-	#++
-
-	def out
-		if @out == '(error)'
-			@out = ''
-			render '/error'
-			@out
-		else
-			@out
-		end
-	end
-
-	# Lazy lookup of the session to avoid costly cookie
-	# lookup when not needed.
-
-	def session
-		@session || @session = Session.lookup(self)
-	end
-
-	# Populate an object from request parameters.
-	# This is a truly dangerous method.
-	
-	EXCLUDED_PARAMETERS = %w{ oid name }
-
-	def fill(obj, name = nil)
-		# if an object is passed create an instance.
-		obj = obj.new if obj.is_a?(Class)
-	
-		@params.each do |param, val|
-			begin
-				# gmosx: DO NOT escape by default !!!
-				if not EXCLUDED_PARAMETERS.include?(param)
-					obj.send("__force_#{param}", val)
-				end
-			rescue NameError
-				next
-			end
-		end
-		
-		return obj
-	end		
-	alias_method :populate, :fill
+  include Request
+  include Response
+  include Render
+
+  # The configuration parameters.
+
+  attr_accessor :conf
+
+  # 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 dispatcher.
+
+  attr_accessor :dispatcher
+
+  def initialize(conf)
+    @conf = conf
+    @dispatcher = @conf.dispatcher
+    @context = self
+
+    # initialize response.
+    
+    @status = CgiUtils::STATUS_OK
+    @response_headers = { 'Content-Type' => 'text/html' }
+
+    # initialize the output buffer.
+
+    @out = OutputBuffer.new
+  end
+
+  # Close the context, should be called at the 
+  # end of the HTTP request handling code.
+
+  def close
+    @session.sync if @session
+  end
+  alias_method :finish, :close
+
+  #--
+  # FIXME: something more elegant/efficient.
+  #++
+
+  def out
+    if @out == '(error)'
+      @out = ''
+      render '/error'
+      @out
+    else
+      @out
+    end
+  end
+
+  # Lazy lookup of the session to avoid costly cookie
+  # lookup when not needed.
+
+  def session
+    @session || @session = Session.lookup(self)
+  end
+
+  # Populate an object from request parameters.
+  # This is a truly dangerous method.
+  
+  EXCLUDED_PARAMETERS = %w{ oid name }
+
+  def fill(obj, name = nil)
+    # if an object is passed create an instance.
+    obj = obj.new if obj.is_a?(Class)
+  
+    @params.each do |param, val|
+      begin
+        # gmosx: DO NOT escape by default !!!
+        if not EXCLUDED_PARAMETERS.include?(param)
+          obj.send("__force_#{param}", val)
+        end
+      rescue NameError
+        next
+      end
+    end
+    
+    return obj
+  end    
+  alias_method :populate, :fill
 end
 
 end