raw 0.49.0

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

@@ -0,0 +1,23 @@
+module Raw
+
+# Transform localzation macros.
+
+class LocalizationFilter
+  
+  def apply(source)
+    source = source.dup
+    
+    # handle symbols.
+    
+    source.gsub!(/\[\[\:(.*?)\]\]/, '#{@lc[\1]}')
+
+    # handle strings.
+     
+    source.gsub!(/\[\[(.*?)\]\]/, '#{@lc["\1"]}')
+
+    return text
+  end
+  
+end
+
+end

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

@@ -0,0 +1,32 @@
+require "raw/util/markup"
+
+module Raw
+
+class MarkupFilter
+
+  # Transform the markup macros.
+  # Maps #(..) to :sanitize.
+  # Maps #|..| to :markup.
+  #
+  # Additional markup macros:
+  #
+  # Maps ''..'' to #{...to_link}
+  # Maps {{..}} to #{R ..}
+  # Maps #<..> to #{R ..}
+  
+  def apply(source)
+    source = source.dup
+    
+    source.gsub!(/\#\((.*?)\)/, '#{sanitize(\1)}')
+    source.gsub!(/\#\|(.*?)\|/, '#{markup(\1)}')
+
+    source.gsub!(/\'\'(.*?)\'\'/, '#{\1.to_link}')    
+    source.gsub!(/\{\{(.*?)\}\}/, '#{R \1}')    
+    source.gsub!(/\#\<(.*?)\>/, '#{R \1}')    
+    
+    return source
+  end
+  
+end
+
+end

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

@@ -0,0 +1,123 @@
+require "rexml/document"
+require "rexml/streamlistener"
+
+require "facets/core/string/blank"
+
+module Raw
+
+# A Filter that transforms an xml stream. Multiple 'key' 
+# attributes are supported per element.
+
+class MorphFilter
+
+  # The default morphers collection.
+  
+  setting :morphers, :default => Dictionary.new, :doc => "The default morphers collection"
+
+  #--
+  # The listener used to parse the xml stream.
+  # TODO: add support for morphing comments, text, etc.
+  #++
+    
+  class Listener # :nodoc: all
+    include REXML::StreamListener
+
+    attr_accessor :buffer
+
+    def initialize(filter)
+      super()
+      @filter = filter
+      @buffer = ""
+      @stack = []
+    end
+
+    def tag_start(name, attributes)    
+      morphers = []
+      
+      for morpher_class in @filter.morphers
+        if attributes.has_key? morpher_class.key
+          morphers << morpher_class.new(name, attributes)
+        end
+      end
+      
+      morphers.each { |h| h.before_start(@buffer) }
+      @buffer << emit_start(name, attributes)
+      morphers.each { |h| h.after_start(@buffer) }
+
+      @stack.push(morphers)      
+    end
+
+    def tag_end(name)    
+      morphers = @stack.pop
+      morphers.reverse.each { |h| h.before_end(@buffer) }
+      @buffer << emit_end(name)
+      morphers.reverse.each { |h| h.after_end(@buffer) }
+    end
+
+    def text(str)
+      @buffer << str
+    end
+    
+    def instruction(name, attributes)
+      @buffer << "<?#{name}#{attributes}?>"
+    end
+
+    def cdata(content)
+      @buffer << "<![CDATA[#{content}]]>"
+    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}>\n"
+    end  
+
+    def emit_start(name, attributes)
+      attrs = attributes.map{ |k, v| %|#{k}="#{v}"| }.join(' ')
+      attrs.blank? ? "<#{name}>" : "<#{name} #{attrs}>"
+    end
+  
+    def emit_end(name)
+      "</#{name}>"
+    end
+  end # Listener
+
+  # A collection of morphers registered with this filter.
+  
+  attr_accessor :morphers
+  
+  # Initialize the filter.
+  
+  def initialize(morphers = nil)
+    unless @morphers = morphers
+      require "raw/compiler/filter/morph/times"
+      require "raw/compiler/filter/morph/each"
+      require "raw/compiler/filter/morph/for"
+      require "raw/compiler/filter/morph/if"
+      require "raw/compiler/filter/morph/selected_if"
+      
+      @morphers = [ 
+        TimesMorpher, 
+        EachMorpher, 
+        ForMorpher, 
+        IfMorpher, 
+        SelectedIfMorpher 
+      ]
+    end
+  end
+
+  # Apply the filter.
+    
+  def apply(source)
+    listen = Listener.new(self)
+    REXML::Document.parse_stream(source, listen)
+    return listen.buffer
+  end
+  
+end
+
+end

data/lib/raw/compiler/filter/morph/each.rb

@@ -0,0 +1,34 @@
+require "raw/compiler/filter/morph/standard"
+
+module Raw
+
+# attribute: each, for
+#
+# <li each="item in array">my item is #{item}</li>
+#
+# becomes
+#
+# <?r for item in array ?>
+#   <li>my item is #{item}</li>
+# <?r end ?>
+
+class EachMorpher < Morpher
+  def self.key
+    "each"
+  end
+  
+  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
+
+end

data/lib/raw/compiler/filter/morph/for.rb

@@ -0,0 +1,11 @@
+require "raw/compiler/filter/morph/each"
+
+module Raw
+
+class ForMorpher < EachMorpher
+  def self.key
+    "for"
+  end
+end
+
+end

data/lib/raw/compiler/filter/morph/if.rb

@@ -0,0 +1,26 @@
+require "raw/compiler/filter/morph/standard"
+
+module Raw
+
+# attribute: if, unless
+#
+# <div prop1="one" if="@mycond" prop2="two">@mycond is true</div>
+#
+# becomes
+#
+# <?r if @mycond ?>
+#   <div prop1="one" prop2="two">@mycond is true</div>
+# <?r end ?>
+
+class IfMorpher < StandardMorpher
+  def self.key
+    "each"
+  end
+  
+  def before_start(buffer)
+    buffer << "<?r #@key #@value ?> "
+    @attributes.delete(@key)
+  end
+end
+
+end

data/lib/raw/compiler/filter/morph/selected_if.rb

@@ -0,0 +1,43 @@
+require "raw/compiler/filter/morph/standard"
+
+module Raw
+
+# attribute: selected_if, checked_if, selected_unless, checked_unless
+#
+# <option value="1" selected_if="@cond">opt1</option>
+#
+# becomes
+#
+# <?r if @cond ?>
+#   <option value="1" selected="selected">opt1</option>
+# <?r else ?>
+#   <option value="1">opt1</option>
+# <?r end ?>
+
+class SelectedIfMorpher < StandardMorpher
+  def self.key
+    "selected_if"
+  end
+  
+  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
+
+end

data/lib/raw/compiler/filter/morph/standard.rb

@@ -0,0 +1,55 @@
+module Raw
+
+# The base morpher class. Morphers are triggered
+# by a special 'key' attribute in the xml stream and
+# transform the owner element. Typically used along with the
+# MorphFilter.
+
+class Morpher
+  # The name of the tag.
+  
+  attr_accessor :name
+  
+  # The tag attributes.
+  
+  attr_accessor :attributes
+  
+  # The key
+  
+  attr_accessor :key
+  
+  # The value of the key.
+  
+  attr_accessor :value
+  
+  
+  def initialize(name, attributes)
+    @key = self.class.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
+
+end

data/lib/raw/compiler/filter/morph/times.rb

@@ -0,0 +1,27 @@
+require "raw/compiler/filter/morph/standard"
+
+module Raw
+
+# attribute: times
+#
+# <li times="3">...</li>
+# 
+# becomes
+#
+# <?r 3.times do ?>
+#   <li>...</li>
+# <?r end ?>
+
+class TimesMorpher < StandardMorpher
+  def self.key
+    "times"
+  end
+  
+  def before_start(buffer)
+    # gmosx: leave the trailing space.
+    buffer << "<?r #@value.times do ?> "
+    @attributes.delete(@key)
+  end
+end
+
+end

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

@@ -0,0 +1,116 @@
+require "facets/core/kernel/constant"
+
+require "raw/helper/javascript"
+
+module Raw
+
+# Generates client-side javascript code.
+# DOES NOT WORK AT THE MOMENT, have to convert this.
+
+module ScriptFilter
+  extend JavascriptHelper
+
+  def self.transform(text, compiler)
+    begin
+      client = constant("#{compiler.controller}::Client")    
+    rescue NameError => ex 
+      client = nil
+    end
+
+    if client
+      client.send :include, Nitro::ScriptGenerator
+      client = client.new
+      
+      functions = {}
+      params = {}
+          
+      text.scan(/__nc_(.*)\((.*)\)/) do |match|
+        functions[match.first] = true
+        params[match.last] = 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 returns a String append it to
+          # the function code.
+          
+          function_code << ret if ret.is_a?(String)
+          
+          script << %{
+            function __nc_#{fun}(params) {
+              #{function_code}
+            }
+          }
+        rescue Object => ex
+          Logger.debug ex.inspect if $DBG
+        end
+      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.
+
+    required_files = Javascript.required_files
+    if crf = compiler.shared[:js_required_files]
+      required_files.concat(crf.keys)
+    end
+    
+    unless required_files.empty?
+      text.sub!(/<\/head>/) do |match|
+        %{
+          #{include_script *required_files}
+        </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!(/<\/body>/) do |match|
+        %{
+          <script type="text/javascript">
+            #{script}
+            #{js_buffer}
+          </script>
+        </body>
+        }
+      end
+    end
+    
+    return text
+  end
+  
+end
+
+end