nitro 0.26.0 → 0.27.0

data/lib/nitro/cgi/response.rb

@@ -16,10 +16,14 @@ module Response
 
   attr_accessor :response_cookies
 
+  # Return the content type for this response.
+  
   def content_type
     @response_headers['Content-Type']
   end
 
+  # Set the content type for this response.
+  
   def content_type=(ctype)
     @response_headers['Content-Type'] = ctype
   end

data/lib/nitro/cgi/stream.rb

@@ -4,14 +4,12 @@ module Nitro
 
 module Render
 
-  # Enable streaming mode for the current
-  # HTTP Response.
-  # You can optionally provide an existing IO 
-  # object for streaming.
+  # 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.
+  # 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)
@@ -41,3 +39,5 @@ module Render
 end
 
 end
+
+# * Guillaume Pierronnet <guillaume.pierronnet@laposte.net>

data/lib/nitro/cgi/utils.rb

@@ -29,7 +29,8 @@ module Request
   end
 
   def from_khtml?
-    user_agent =~ /KTHML/
+    puts "agent = #{user_agent}"
+    user_agent =~ /KHTML/
   end
   alias_method :from_safari?, :from_khtml?
 

data/lib/nitro/compiler.rb

@@ -6,14 +6,17 @@ require 'nitro/compiler/elements'
 require 'nitro/compiler/errors'
 require 'nitro/compiler/markup'
 require 'nitro/compiler/morphing'
+require 'nitro/compiler/script'
 require 'nitro/compiler/include'
 require 'nitro/compiler/cleanup'
+require 'nitro/compiler/layout'
 
 module Nitro
 
 # The Compiler transforms published methods (actions) and 
 # assorted template files (views) into specialized code that 
-# responds to a URI.
+# responds to a URI. The generated action methods are injects
+# in the Controller that handles the URI.
 
 class Compiler
   unless const_defined? :PROTO_TEMPLATE_ROOT
@@ -23,7 +26,14 @@ class Compiler
   # The controller for this compiler.
   
   attr_accessor :controller
+
+  # The compiler stages (compilers) can create multiple variables
+  # or accumulation bufffers to communicate with each other. 
+  # Typically javascript and css acc-buffers are used. This is 
+  # the shared memory used by the compilers.
   
+  attr_accessor :shared
+    
   # Set to true to force reloading of code and templates for
   # each request. Extremely useful during development. Must be
   # turned off in production servers to avoid the severe
@@ -33,6 +43,7 @@ class Compiler
 
   def initialize(controller = nil)
     @controller = controller
+    @shared = {}
   end
 
   # Action names with double underscores (__) are converted
@@ -92,9 +103,11 @@ class Compiler
   
   def transform_template(template)
     template = StaticInclude.transform(template)
-    template = Morphing.transform(template)
-    template = Elements.transform(template)
+    template = Morphing.transform(template, self)
+#   template = LayoutCompiler.transform(template, self)
+    template = Elements.transform(template, self)
     template = Markup.transform(template)
+    template = ScriptCompiler.transform(template, self)
     template = Cleanup.transform(template)
     template = Template.transform(template)
   end
@@ -121,10 +134,40 @@ class Compiler
     end        
   end
 
-  # Compiles an action.
+  # Compiles an action. The generated action combines the 
+  # action supplied by the programmer and an optional template
+  # in an optimized method to handle the input URI.
   #
   # Passes the action name and the parent action name in the
   # @action_name and @parent_action_name respectively.
+  #
+  # === Example
+  #
+  # def my_method
+  # template_root/my_method.xhtml
+  # 
+  # are combined in: 
+  #
+  # def my_method_action
+  #
+  # This generated method is called by the dispatcher.
+  #
+  # === Template root overloading
+  #
+  # Nitro provides a nice method of template_root overloading
+  # that allows you to use OOP principles with templates.
+  # Lets say you have the following controller inheritance.
+  #
+  # SpecificController < BaseController < Nitro::Controller
+  #
+  # When the compiler tries to find a template for the
+  # SpecificController, it first looks into SC's template root.
+  # If no suitable template is found, it looks into 
+  # BaseController's template_root etc. The final template_root
+  # is always the Nitro proto dir (the prototype application).
+  # This way you can reuse Controllers and templates and only
+  # overriding the templates as required by placing a template
+  # with the same name in the more specific template root.
   #--
   # TODO: cleanup this method.
   #++

data/lib/nitro/compiler/elements.rb

@@ -9,7 +9,7 @@ module Nitro
 # A compiler that handles the processing of Elements
 
 class Elements # :nodoc: all
-
+  
   class Listener # :nodoc: all
     include REXML::StreamListener
     
@@ -28,21 +28,36 @@ class Elements # :nodoc: all
     def tag_start(name, attributes)    
       # check if the name starts with the element prefix, or
       # is capitalized.
+      
       if name =~ PREFIX_RE or name =~ CAPITALIZED_RE    
         name = name.split(':')[1].camelize if name =~ PREFIX_RE
-        
-        obj = Object.const_get(name).new
-        
-        attributes.each do | k, v | 
-          obj.instance_variable_set("@#{k}", v)
-        end        
-        
-        @stack.push [obj, @buffer, @parent]
-        
-        @buffer = obj._text
-        @parent.add_child(obj) if @parent
-        
-        @parent = obj
+
+        # First try to use Nitro::Element::xxx then ::xxx
+                
+        if klass = Nitro::Element.const_get(name) || Object.const_get(name)
+          unless klass.ancestors.include? Nitro::Element
+            if Element.auto_extend
+              klass.send(:include, Nitro::ElementMixin)
+            else
+              Logger.error "Invalid element class '#{name}', does not extend Nitro::Element"
+            end
+          end
+        else
+          Logger.error "The class of this element tag '#{name}' does not exist"
+        end
+                        
+        if klass and obj = klass.new        
+          attributes.each do | k, v | 
+            obj.instance_variable_set("@#{k}", v)
+          end        
+          
+          @stack.push [obj, @buffer, @parent]
+          
+          @buffer = obj._text
+          @parent.add_child(obj) if @parent
+          
+          @parent = obj
+        end
       else # This is a static element.
         attrs = []
         
@@ -88,19 +103,23 @@ class Elements # :nodoc: all
       self.new.parse(source)
     end
     
-    def transform(source)
-      self.new.transform(source)
+    def transform(source, compiler)
+      self.new.transform(source, compiler)
     end
   end
 
   # Expand the elemens found in source.
+  #--
+  # gmosx, FIXME: optimize this, how?
+  # gmosx, FIXME: this is a hack fix, improve.
+  # TODO:farms why is cleanup called this many times?!?!? ... waste of gsubs
+  #++
     
-  def transform(source)
+  def transform(source, compiler)
     listener = Listener.new
+
     REXML::Document.parse_stream(source, listener)
-    # gmosx, FIXME: optimize this, how?
-    # gmosx, FIXME: this is a hack fix, improve.
-    # TODO:farms why is cleanup called this many times?!?!? ... waste of gsubs
+    
     return listener.buffer
   end
 end
@@ -109,6 +128,7 @@ end
 
 unless const_defined? :ElementProcessor
    ElementProcessor = Elements
+   ElementCompiler = Elements
 end
 
 end

data/lib/nitro/compiler/layout.rb

@@ -0,0 +1,21 @@
+module Nitro
+
+# A compiler that handles Rails style simplistic layouts. 
+# Perhaps this will be useful for some people that are comming
+# from Rails.
+
+class LayoutCompiler # :nodoc: all
+
+  def self.transform(source, compiler)
+    if layout = compiler.controller.ann.self[:layout]
+      return "<#{layout}>#{source}</#{layout}>"
+    else 
+      return source
+    end
+  end
+  
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/nitro/compiler/localization.rb

@@ -1,6 +1,6 @@
 require 'glue/localization'
 
-module Glue
+module Nitro
 
 class Localization
 
@@ -23,3 +23,5 @@ class Localization
 end
 
 end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/nitro/compiler/markup.rb

@@ -19,3 +19,5 @@ module Markup
 end
 
 end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/nitro/compiler/morphing.rb

@@ -12,14 +12,19 @@ module Nitro
 
 # The base morpher class. Morphers are triggered
 # by a special 'key' attribute in the xml stream and
-# transform the owner element.
+# transform the owner element. 
+#
+# key = attribute 'key'
+# name = element name
+# attributes = alement attributes
 
 class Morpher
-  def initialize(key, name, attributes)
+  def initialize(key, name, attributes, compiler = nil)
     @key = key
     @name = name
     @attributes = attributes
     @value = @attributes[@key]
+    @compiler = compiler
   end
   
   def before_start(buffer); end
@@ -148,6 +153,12 @@ class Morphing
   class Listener # :nodoc: all
     include REXML::StreamListener
 
+    # The compiler that calls this compiling stage. Useful
+    # for advanced morphing effects and inter-stage 
+    # communication.
+    
+    attr_accessor :compiler
+
     attr_accessor :buffer
     
     def initialize
@@ -167,7 +178,7 @@ class Morphing
       
       Morphing.morphers.each do |key, morpher_class|
         if attributes.has_key? key
-          morphers << morpher_class.new(key, name, attributes)
+          morphers << morpher_class.new(key, name, attributes, compiler)
         end
       end
       
@@ -214,8 +225,9 @@ class Morphing
     "</#{name}>"
   end
   
-  def self.transform(source)
+  def self.transform(source, compiler = nil)
     listener = Listener.new
+    listener.compiler = compiler
     REXML::Document.parse_stream(source, listener)
     return listener.buffer
   end

data/lib/nitro/compiler/script.rb

@@ -0,0 +1,109 @@
+require 'nano/kernel/constant'
+
+require 'nitro/helper/javascript'
+
+module Nitro
+
+# Generates client-side javascript code.
+
+module ScriptCompiler
+  extend JavascriptHelper
+  
+  def self.transform(text, compiler)
+    begin
+      client = constant("#{compiler.controller}::Client")    
+    rescue Object 
+      client = nil
+    end
+
+    if client
+      client.send :include, Nitro::ScriptGenerator
+      client = client.new
+      
+      functions = {}
+          
+      text.scan(/__nc_(.*)\(\)/) do |match|
+        functions[match.first] = true
+      end    
+      
+      script = ''
+      
+      for fun in functions.keys
+        begin
+          client.buffer = ''
+          ret = client.send(fun.to_sym)
+          
+          # the function code is accumulated in the client 
+          # buffer.
+          
+          function_code = client.buffer
+          
+          # if the client action returs a String append it to
+          # the function code.
+          
+          function_code << ret if ret.is_a?(String)
+          
+          script << %{
+            function __nc_#{fun}() {
+              #{function_code}
+            }
+          }
+        rescue => ex
+          Logger.debug ex.inspect if $DBG
+        end
+      end
+
+      # Inject css in the head tag.
+      
+      if css_buffer = compiler.shared[:css_buffer]
+        text.sub!(/<\/head>/) do |match|
+          %{
+            <style>
+              #{css_buffer}
+            </style>
+          </head>
+          }
+        end
+      end
+
+      # Inject required javascript files in the head tag.
+      
+      if required_files = compiler.shared[:js_required_files]
+        text.sub!(/<\/head>/) do |match|
+          %{
+            #{include_script *required_files.keys}
+          </head>
+          }
+        end
+      end
+      
+      # Inject javascript just before the end of the
+      # template.
+      #--
+      # gmosx: injection happens at the end, so that the DOM
+      # tree is created. Dunno if this is valid xhtml though.
+      #++
+
+      js_buffer = compiler.shared[:js_buffer]
+      
+      if script or js_buffer
+        text.sub!(/<\/html>/) do |match|
+          %{
+            <script type="text/javascript">
+              #{script}
+              #{js_buffer}
+            </script>
+          </html>
+          }
+        end
+      end
+    end  
+    
+    return text
+  end
+  
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>