nitro 0.25.0 → 0.26.0

data/lib/nitro/compiler/markup.rb

@@ -3,7 +3,9 @@ require 'glue/markup'
 module Nitro
 
 module Markup
-
+  
+  include Glue::Markup
+  
   # Transform the markup macros.
   # Maps #(..) to :sanitize.
   # Maps #|..| to :markup.

data/lib/nitro/compiler/morphing.rb

@@ -1,95 +1,190 @@
 require 'rexml/document'
 require 'rexml/streamlistener'
 
+require 'mega/dictionary'
+require 'nano/string/blank'
+
+require 'glue/html'
+
 module Nitro
 
-# A compiler that handles these attribute's tags:
+# :section: A collection of standard morphers.
+
+# The base morpher class. Morphers are triggered
+# by a special 'key' attribute in the xml stream and
+# transform the owner element.
+
+class Morpher
+  def initialize(key, name, attributes)
+    @key = key
+    @name = name
+    @attributes = attributes
+    @value = @attributes[@key]
+  end
+  
+  def before_start(buffer); end
+  def after_start(buffer); end
+  def before_end(buffer); end
+  def after_end(buffer); end
+end
+
+# A useful super class for morphers.
+
+class StandardMorpher < Morpher
+  def after_end(buffer)
+    # gmosx: leave the leading space.
+    buffer << " <?r end ?>"
+  end
+end
+
+# attribute: times
 #
-# <tag if="x">..</tag>
-# <tag unless="x">..</tag>
-# <tag each="x">..</tag>
-# <tag times="x">..</tag>
+# <li times="3">...</li>
+# 
+# becomes
 #
-# by transforming them like that
+# <?r 3.times do ?>
+#   <li>...</li>
+# <?r end ?>
+
+class TimesMorpher < StandardMorpher
+  def before_start(buffer)
+    # gmosx: leave the trailing space.
+    buffer << "<?r #@value.times do ?> "
+    @attributes.delete(@key)
+  end
+end
+
+# attribute: each, for
 #
-# <div prop1="one" if="@mycond" prop2="two">@mycond is true</div>
+# <li each="item in array">my item is #{item}</li>
 #
 # becomes
 #
-# <?r if @mycond ?>
-#   <div prop1="one" prop2="two">@mycond is true</div>
+# <?r for item in array ?>
+#   <li>my item is #{item}</li>
 # <?r end ?>
+
+class EachMorpher < Morpher
+  def before_start(buffer)
+    if @value =~ / in /
+      buffer << "<?r for #@value ?> "
+      @attributes.delete(@key)
+    end
+  end
+  
+  def after_end(buffer)
+    if @value =~ / in /
+      buffer << " <?r end ?>"
+    end
+  end
+end
+
+# attribute: if, unless
 #
+# <div prop1="one" if="@mycond" prop2="two">@mycond is true</div>
 #
-# <li times="3">...</li>
-# 
 # becomes
 #
-# <?r 3.times do ?>
-# <li>...</li>
+# <?r if @mycond ?>
+#   <div prop1="one" prop2="two">@mycond is true</div>
 # <?r end ?>
+
+class IfMorpher < StandardMorpher
+  def before_start(buffer)
+    buffer << "<?r #@key #@value ?> "
+    @attributes.delete(@key)
+  end
+end
+
+# attribute: selected_if, checked_if, selected_unless, checked_unless
 #
-#
-# <li each="item in array">my item is #{item}</li>
+# <option value="1" selected_if="@cond">opt1</option>
 #
 # becomes
 #
-# <?r for item in array ?>
-#   <li>my item is #{item}</li>
+# <?r if @cond ?>
+#   <option value="1" selected="selected">opt1</option>
+# <?r else ?>
+#   <option value="1">opt1</option>
 # <?r end ?>
 
+class SelectedIfMorpher < StandardMorpher
+  def before_start(buffer)
+    @attr, @cond = @key.split('_')
+    @attributes.delete(@key)
+    @attributes[@attr] = @attr
+    buffer << "<?r #@cond #@value ?> "
+  end
+  
+  def after_start(buffer)
+    @start_index = buffer.length
+  end
+  
+  def before_end(buffer)
+    @attributes.delete(@attr)
+    @end_index = buffer.length
+    buffer << Morphing.emit_end(@name)
+    buffer << "<?r else ?>"
+    buffer << Morphing.emit_start(@name, @attributes)
+    buffer << buffer[@start_index...@end_index]
+  end
+    
+end
+
+# :section: The morphing system.
+
+# A compiler module that translates xml stream. Multiple
+# 'key' attributes are supported per element.
+
 class Morphing
 
+  #--
+  # The listener used to parse the xml stream.
+  #
+  # TODO: add support for morphing comments, text, etc.
+  #++
+    
   class Listener # :nodoc: all
     include REXML::StreamListener
-    
-    attr_reader :buffer
+
+    attr_accessor :buffer
     
     def initialize
       super
       @buffer = ''
       @stack = []
-      @depth = 0
     end
-    
+
     def tag_start(name, attributes)    
-      if attr = attributes.detect { |k, v| %w{if unless for each times}.include?(k) }
-        temp_buffer = 
-          if attr[0] == 'times'
-            "<?r #{attr[1]}.times do ?>"
-          elsif (attr[0] == 'for' or attr[0] == 'each') and attr[1] =~ / in /
-            "<?r for #{attr[1]} ?>"
-          elsif attr[0] == 'if' or attr[0] == 'unless'
-            "<?r #{attr[0]} #{attr[1]} ?>"
-          else
-            Logger.info "Morphing: #{attr[0]} attribute found but was not suitable for morphing" if $DBG
-            false
-        end
-        if temp_buffer
-          @buffer << temp_buffer
-          attributes.delete(attr[0])
-          @stack.push(@depth)
-        end
-      end
+      morphers = []
+      
+      #for key, val in attributes
+      #  if morpher_class = Morphing.morphers[key]
+      #    morphers << morpher_class.new(key, name, attributes)
+      #  end
+      #end
       
-      attrs = attributes.collect do | k, v | 
-        %|#{k}="#{v}"|
+      Morphing.morphers.each do |key, morpher_class|
+        if attributes.has_key? key
+          morphers << morpher_class.new(key, name, attributes)
+        end
       end
       
-      attrs = attrs.empty? ? "" : " " + attrs.join(' ')
-      @depth += 1
-      @buffer << "<#{name}#{attrs}>"
+      morphers.each { |h| h.before_start(@buffer) }
+      @buffer << Morphing.emit_start(name, attributes)
+      morphers.each { |h| h.after_start(@buffer) }
+
+      @stack.push(morphers)      
     end
 
     def tag_end(name)    
-      @depth -= 1
-      @buffer << "</#{name}>"
-      if @stack.last == @depth
-        @buffer << "\n<?r end ?>"
-        @stack.pop
-      end
+      morphers = @stack.pop
+      morphers.reverse.each { |h| h.before_end(@buffer) }
+      @buffer << Morphing.emit_end(name)
+      morphers.reverse.each { |h| h.after_end(@buffer) }
     end
-    
+
     def text(str)
       @buffer << str
     end
@@ -97,6 +192,26 @@ class Morphing
     def instruction(name, attributes)
       @buffer << "<?#{name}#{attributes}?>"
     end
+
+    def comment(c)
+      unless Template.strip_xml_comments
+        @buffer << "<!--#{c}-->"
+      end
+    end    
+
+    def doctype(name, pub_sys, long_name, uri)   
+      @buffer << "<!DOCTYPE #{name} #{pub_sys} #{long_name} #{uri}>"
+    end
+  end
+
+
+  def self.emit_start(name, attributes)
+    attrs = attributes.map{ |k, v| %|#{k}="#{v}"| }.join(' ')
+    attrs.blank? ? "<#{name}>" : "<#{name} #{attrs}>"
+  end
+  
+  def self.emit_end(name)
+    "</#{name}>"
   end
   
   def self.transform(source)
@@ -105,32 +220,47 @@ class Morphing
     return listener.buffer
   end
 
-end
+  # The morphers map.
+  
+  @morphers = Dictionary.new
+  
+  class << self
+  
+    def morphers
+      @morphers
+    end
+
+    def morphers=(hash)
+      @morphers = hash
+    end
+    
+    def add_morpher(key, klass)
+      @morphers[key.to_s] = klass
+    end
+    alias_method :add, :add_morpher
+    
+    def delete_morpher(key)
+      @morphers.delete(key)
+    end
+    alias_method :delete, :delete_morpher
+  end
 
+  # Install the default morphers.
+  
+  add_morpher :times, TimesMorpher
+  add_morpher :if, IfMorpher
+  add_morpher :unless, IfMorpher
+  add_morpher :each, EachMorpher
+  add_morpher :for, EachMorpher
+  add_morpher :selected_if, SelectedIfMorpher
+  add_morpher :selected_unless, SelectedIfMorpher
+  add_morpher :checked_if, SelectedIfMorpher
+  add_morpher :checked_unless, SelectedIfMorpher
+  
 end
 
-if __FILE__ == $0
-  puts Nitro::Morphing.transform(<<EOF)
-<body>
-  <child attr1="attr1" if="test" attr2="attr2">
-    <mytag>
-      this is texxt
-      <one if="@qsdf">
-        qqqqq
-      </one>
-    </mytag>
-  </child>
-  <child times="4">
-    <mytag>
-      qqqqq
-    </mytag>
-    <one if="@qsdf">
-      text
-    </one>
-  </child>
-</body>
-EOF
 end
 
 # * George Moschovitis <gm@navel.gr>
 # * Guillaume Pierronnet <guillaume.pierronnet@gmail.com>
+# * Chris Farmiloe <chris.farmiloe@farmiloe.com>

data/lib/nitro/compiler/script_generator.rb

@@ -0,0 +1,14 @@
+require 'glue/markup'
+
+module Nitro
+
+# Generates in-page javascript 
+
+module ScriptGenerator
+
+  def self.transform(text)
+  end
+  
+end
+
+end

data/lib/nitro/compiler/shaders.rb

@@ -1,5 +1,5 @@
 require 'nitro/template'
-require 'nitro/element'
+require 'nitro/compiler/elements'
 
 module Nitro
 

data/lib/nitro/context.rb

@@ -60,17 +60,16 @@ class Context
   alias_method :finish, :close
 
   #--
-  # FIXME: something more elegant/efficient.
+  # FIXME: still something more elegant/efficient.
   #++
 
   def out
-    if @out == '(error)'
-      @out = ''
+    return @out if @out == ""
+    if @rendering_errors
+      @out = String.new
       render '/error'
-      @out
-    else
-      @out
     end
+    @out
   end
 
   # Lazy lookup of the session to avoid costly cookie

data/lib/nitro/controller.rb

@@ -5,35 +5,19 @@ require 'glue/markup'
 
 require 'nitro'
 require 'nitro/render'
-require 'nitro/scaffold'
+require 'nitro/scaffolding'
 require 'nitro/caching'
 require 'nitro/flash'
 require 'nitro/helper'
 
 module Nitro
 
-# Encapsulates metadata that describe an action 
-# parameter. 
-# 
-#  [+default+]
-#    The default value.
-#
-#  [+format+]
-#    The expected format.
-#
-#  [+required+]
-#    Is this parameter required?
-
-unless const_defined? :ActionParam
-  ActionParam = Struct.new(:default, :format, :required)
-end
-
 # Include this Mixin to a class to make objects of this class
 # publishable, ie accessible through a standard web (REST) 
 # interface.
 
 module Publishable
-  def self.append_features(base)
+  def self.included(base)
     super
 
     base.module_eval do
@@ -55,7 +39,7 @@ module Publishable
       # Helper method.
       
       def template_root
-        self.class.template_root || Template.root
+        self.class.template_root
       end
     end
 
@@ -100,7 +84,7 @@ module Publishable
   
     base.module_eval do
       def method_missing(action, *args)
-        if Compiler.new.compile(self.class, action)
+        if Compiler.new(self.class).compile(action)
           send(action, *args)
         else
           super
@@ -108,6 +92,33 @@ module Publishable
       end
     end    
 
+    # Does this publishable respond to the given action?
+    
+    base.module_eval do
+      class << self
+        def respond_to_action?(action)
+          action_methods.include?(action.to_s)              
+        end
+        alias_method :action?, :respond_to_action?
+      end
+    end
+        
+    # Does this class respond to the given action? 
+    # Also looks for templates in the template root.
+    #
+    # Prefer to use the compiler for this.
+    #--
+    # THINK: maybe move template? here
+    #++
+  
+    base.module_eval do
+      class << self
+        def respond_to_action_or_template?(sym)
+          return self.respond_to_action?(sym.to_s) || Compiler.new(self).template?(sym)             
+        end
+      end
+    end
+
     # Cookie helpers.
     #--
     # TODO: move elsewhere.
@@ -138,9 +149,20 @@ class Controller
   include Caching
   include Helpers
   helper Markup
+
+  # This callback is called after the Controller is mounted.
+  
+  def self.mounted(path)
+    # Resolve aspects.
+    Aspects.include_advice_modules(self)
+      
+    # The scaffolding code is compiled after the mount, so 
+    # that template roots are finalized.
+    compile_scaffolding_code
+  end
+  
 end
 
 end
 
 # * George Moschovitis <gm@navel.gr>
-