zafu 0.5.0

data/lib/zafu/parsing_rules.rb

@@ -0,0 +1,257 @@
+require 'zafu/markup'
+
+module Zafu
+  module ParsingRules
+    # The context informs the rendering element about the current Node, node class, existing ids, etc. The
+    # context is inherited by sub-elements.
+    attr_reader :context
+
+    # The helper is used to connect the compiler to the world of the application (read/write templates, access traductions, etc)
+    attr_reader :helper
+
+    # The markup (of class Markup) holds information on the tag (<li>), tag attributes (.. class='foo') and
+    # indentation information that should be used when rendered. This context is not inherited.
+    attr_accessor :markup
+
+    # This callback is run just after the block is initialized (Parser#initialize).
+    def start(mode)
+      # tag_context
+      @markup = Markup.new(@options.delete(:html_tag))
+
+      # html_tag
+      @markup.params = @options.delete(:html_tag_params) # @html_tag_params
+
+      # have we already wrapped the result with our tag ?
+      @markup.done = false # @html_tag_done
+
+      # end_tag is used to know when to close parsing in sub-do
+      # Example:
+      # <li do='each' do='images'>
+      #   <ul>
+      #     <li><r:link/></li> <!-- do not close outer LI now: @end_tag_count != 0 -->
+      #   </ul>
+      # </li> <!-- close outer LI now: @end_tag_count == 0 -->
+      #
+      @end_tag = @markup.tag || @options.delete(:end_tag) || "r:#{@method}"
+      @end_tag_count  = 1
+
+      # code indentation
+      @markup.space_before = @options.delete(:space_before) # @space_before
+
+      # form capture (input, select, textarea, form)
+      # FIXME: what is this ???
+      @options[:form] ||= true if @method == 'form'
+
+      # puts "[#{@markup[:space_before]}(#{@method})#{@markup[:space_after]}]"
+      if @params =~ /\A([^>]*?)do\s*=('|")([^\2]*?[^\\])\2([^>]*)\Z/
+        # we have a sub 'do'
+        @params = Markup.parse_params($1)
+        @sub_do = $3 # this is used by replace_with (FIXME)
+
+        opts = {:method=>$3, :params=>$4}
+
+        # the matching zafu tag will be parsed by the last 'do', we must inform it to halt properly :
+        opts[:end_tag] = @end_tag
+
+        sub = make(:void, opts)
+        @markup.space_after = sub.markup.space_after
+        sub.markup.space_after = ""
+      else
+        @params = Markup.parse_params(@params)
+      end
+
+      # set name used for include/replace from html_tag if not allready set by superclass
+      @name = @options[:name] || @params[:name] || @params[:id] || @markup.params[:id]
+
+      if !@markup.tag && (@markup.tag = @params.delete(:tag))
+        # Extract html tag parameters from @params
+        @markup.steal_html_params_from(@params)
+      end
+
+      if @method == 'include'
+        include_template
+      elsif mode == :tag && !sub
+        scan_tag
+      elsif !sub
+        enter(mode)
+      end
+    end
+
+    def before_parse(text)
+      text.gsub('<%', '&lt;%').gsub('%>', '%&gt;')
+    end
+
+    # scan rules
+    def scan
+      # puts "SCAN(#{@method}): [#{@text}]"
+      if @text =~ /\A([^<]*?)(^ *|)</m
+        flush $1
+        eat $2
+        if @text[1..1] == '/'
+          store $2
+          scan_close_tag
+        elsif @text[0..3] == '<!--'
+          scan_html_comment(:space_before=> $2)
+        elsif @text[0..8] == '<![CDATA['
+          flush '<![CDATA['
+        else
+          scan_tag(:space_before=> $2)
+        end
+      else
+        # no more tags
+        flush
+      end
+    end
+
+    def scan_close_tag
+      if @text =~ /\A<\/([^>]+)>( *\n+|)/m
+        # puts "CLOSE:[#{$&}]}" # ztag
+        # closing tag
+        if $1 == @end_tag
+          @end_tag_count -= 1
+          if @end_tag_count == 0
+            if @end_tag == 'script'
+              flush $& # keep closing tag
+            else
+              eat $&
+            end
+            @markup.space_after = $2
+            leave
+          else
+            # keep the tag (false alert)
+            flush $&
+          end
+        elsif $1[0..1] == 'r:'
+          # /rtag
+          eat $&
+          if $1 != @end_tag
+            # error bad closing rtag
+            store "<span class='parser_error'>#{$&.gsub('<', '&lt;').gsub('>','&gt;')} should be &lt;/#{@end_tag}&gt;</span>"
+          end
+          leave
+        else
+          # other html tag closing
+          flush $&
+        end
+      else
+        # error
+        flush
+      end
+    end
+
+    def scan_html_comment(opts={})
+      if @text =~ /\A<!--\|(.*?)-->/m
+        # zafu html escaped
+        eat $&
+        @text = opts[:space_before] + $1 + @text
+      elsif @text =~ /\A<!--.*?-->/m
+        # html comment
+        flush $&
+      else
+        # error
+        flush
+      end
+    end
+
+    def scan_tag(opts={})
+      #puts "TAG(#{@method}): [#{@text}]"
+      if @text =~ /\A<r:([\w_]+)([^>]*?)(\/?)>/
+        #puts "RTAG:#{$~.to_a.inspect}" # ztag
+        eat $&
+        opts.merge!(:method=>$1, :params=>$2)
+        opts.merge!(:text=>'') if $3 != ''
+        make(:void, opts)
+      elsif @text =~ /\A<(\w+)([^>]*?)do\s*=('([^>]*?[^\\]|)'|"([^>]*?[^\\]|)")([^>]*?)(\/?)>/
+        #puts "DO:#{$~.to_a.inspect}" # do tag
+        eat $&
+        opts.merge!(:method=>($4||$5), :html_tag=>$1, :html_tag_params=>$2, :params=>$6)
+        opts.merge!(:text=>'') if $7 != ''
+        make(:void, opts)
+      elsif @options[:form] && @text =~ /\A<(input|select|textarea|form)([^>]*?)(\/?)>/
+        eat $&
+        method = $1 == 'form' ? 'form_tag' : $1 # <form> ==> r_form_tag, <r:form> ==> r_form
+        opts.merge!(:method=>method, :params=>$2)
+        opts.merge!(:text=>'') if $3 != ''
+        opts.merge!(:end_tag=>'form') if method == 'form_tag'
+        make(:void, opts)
+      elsif @text =~ /\A<(\w+)(([^>]*?)\#\{([^>]*?))(\/?)>/
+        # html tag with dynamic params
+        #puts "OTHER_DYN:[#{$&}]"
+
+        eat $&
+        opts.merge!(:method => 'void', :html_tag => $1, :html_tag_params => $2, :params => {})
+        opts.merge!(:text=>'') if $5 != ''
+        make(:void, opts)
+      elsif @text =~ /\A<(\w+)([^>]*?)id\s*=('[^>]*?[^\\]'|"[^>]*?[^\\]")([^>]*?)(\/?)>/
+        #puts "ID:#{$~.to_a.inspect}" # id tag
+        eat $&
+        opts.merge!(:method=>'void', :html_tag=>$1, :params=>{:id => $3[1..-2]}, :html_tag_params=>"#{$2}id=#{$3}#{$4}")
+        opts.merge!(:text=>'') if $5 != ''
+        make(:void, opts)
+      elsif @end_tag && @text =~ /\A<#{@end_tag}([^>]*?)(\/?)>/
+        #puts "SAME:#{$~.to_a.inspect}" # simple html tag same as end_tag
+        flush $&
+        @end_tag_count += 1 unless $2 == '/'
+      elsif @text =~ /\A<(link|img|script)/
+        #puts "HTML:[#{$&}]" # html
+        make(:asset)
+      elsif @text =~ /\A<style>/
+        flush $&
+        make(:style)
+      elsif @text =~ /\A[^>]*?>/
+        # html tag
+        #puts "OTHER:[#{$&}]"
+        store opts[:space_before]
+        flush $&
+      else
+        # never closed tag
+        flush
+      end
+    end
+
+    def scan_asset
+      # puts "ASSET(#{object_id}) [#{@text}]"
+      if @text =~ /\A<(\w*)([^>]*?)(\/?)>/
+        eat $&
+        @method = 'rename_asset'
+        @markup.tag = @end_tag = $1
+        closed = ($3 != '')
+        @params = parse_params($2)
+        if closed
+          leave(:asset)
+        elsif @markup.tag == 'script'
+          enter(:void)
+        else
+          enter(:inside_asset)
+        end
+      else
+        # error
+        @method = 'void'
+        flush
+      end
+    end
+
+    def scan_inside_asset
+      if @text =~ /\A(.*?)<\/#{@end_tag}>/m
+        flush $&
+        leave(:asset)
+      else
+        # never ending asset
+        flush
+      end
+    end
+
+    def scan_style
+      if @text =~ /\A(.*?)<\/style>/m
+        flush $&
+        @method = 'rename_asset'
+        @markup.tag = 'style'
+        leave(:style)
+      else
+        # error
+        @method = 'void'
+        flush
+      end
+    end
+  end # ParsingRules
+end # Zafu

data/lib/zafu/process/ajax.rb

@@ -0,0 +1,90 @@
+module Zafu
+  module Process
+    module Ajax
+
+      # Store a context as a sub-template that can be used in ajax calls
+      def r_block
+
+        # 1. store template
+        store_block(self)
+        out expand_with
+      end
+
+
+      private
+        def store_block(block)
+          # Save current rendering information (id, html_tag_done, html_tag_params)
+          markup_bak = block.markup.dup
+
+          # Creatae new node context
+          node_context = node.as_main
+
+          # Change rendering context
+          block.markup.done = false
+          block.markup.set_id(node.dom_id) # "<%= dom_id(#{node}) %>"
+        end
+
+        template = expand_block(self, :)
+
+        if @context[:block] == self
+          # called from self (storing template)
+          @context.reject! do |k,v|
+            # FIXME: reject all stored elements in a  better way then this
+            k.kind_of?(String) && k =~ /\ANode_\w/
+          end
+          @markup.done = false
+          @markup.params.merge!(:id=>erb_dom_id)
+          @context[:scope_node] = node if @context[:scope_node]
+          out expand_with(:node => node)
+          if @method == 'drop' && !@context[:make_form]
+            out drop_javascript
+          end
+        else
+          if parent.method == 'each' && @method == parent.single_child_method
+            # use parent as block
+            # FIXME: will not work with block as distant target...
+            # do nothing
+          else
+            @markup.tag ||= 'div'
+            new_dom_scope
+
+            unless @context[:make_form]
+              # STORE TEMPLATE ========
+
+              context_bak = @context.dup # avoid side effects when rendering the same block
+              ignore_list = @method == 'block' ? ['form'] : [] # do not show the form in the normal template of a block
+              template    = expand_block(self, :block=>self, :list=>false, :saved_template=>true, :ignore => ignore_list)
+              @context    = context_bak
+              @result     = ''
+              out helper.save_erb_to_url(template, template_url)
+
+              # STORE FORM ============
+              if edit = descendant('edit')
+                publish_after_save = (edit.params[:publish] == 'true')
+                if form = descendant('form')
+                  # USE BLOCK FORM ========
+                  form_text = expand_block(form, :saved_template=>true, :publish_after_save => publish_after_save)
+                else
+                  # MAKE A FORM FROM BLOCK ========
+                  form = self.dup
+                  form.method = 'form'
+                  form_text = expand_block(form, :make_form => true, :list => false, :saved_template => true, :publish_after_save => publish_after_save)
+                end
+                out helper.save_erb_to_url(form_text, form_url)
+              end
+            end
+
+            # RENDER
+            @markup.done = false
+            @markup.params.merge!(:id=>erb_dom_id)
+          end
+
+          out expand_with
+          if @method == 'drop' && !@context[:make_form]
+            out drop_javascript
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zafu/process/conditional.rb

@@ -0,0 +1,45 @@
+module Zafu
+  module Process
+    # This module manages conditional rendering (if, else, elsif, case, when).
+    module Conditional
+      def r_if
+        "<% if true -%>#{expand_with(:in_if => true)}<% end -%>"
+      end
+
+      def r_else
+        return nil unless @context[:in_if]
+        # We use 'elsif' just in case there are more then one 'else' clause
+        out "<% elsif true -%>#{expand_with(:in_if => false)}" # do not propagate
+      end
+
+      def helper
+        @context[:helper]
+      end
+
+      # Return the node context for a given class (looks up into the hierarchy) or the
+      # current node context if klass is nil.
+      def node(klass = nil)
+        return @context[:node] if !klass
+        @context[:node].get(klass)
+      end
+
+      def expand_with_node(name, klass)
+        expand_with(:node => @context[:node].move_to(name, klass))
+      end
+
+      # def context_with_node(name, klass)
+      #   context = @context.dup
+      #   context[:node] = context[:node].move_to(name, klass)
+      # end
+
+      def var
+        return @var if @var
+        if node.name =~ /^var(\d+)$/
+          @var = "var#{$1.to_i + 1}"
+        else
+          @var = "var1"
+        end
+      end
+    end # Context
+  end # Process
+end # Zafu

data/lib/zafu/process/context.rb

@@ -0,0 +1,45 @@
+module Zafu
+  module Process
+    # This module manages the change of contexts by opening (each) or moving into the NodeContext.
+    # The '@context' holds many information on the current compilation environment. Inside this
+    # context, the "node" context holds information on the type of "this" (first responder).
+    module Context
+      def r_each
+        if node.klass.kind_of?(Array)
+          out "<% #{node}.each do |#{var}| -%>"
+          out render_html_tag(expand_with_node(var, node.klass.first))
+          out "<% end -%>"
+        end
+      end
+
+      def helper
+        @context[:helper]
+      end
+
+      # Return the node context for a given class (looks up into the hierarchy) or the
+      # current node context if klass is nil.
+      def node(klass = nil)
+        return @context[:node] if !klass
+        @context[:node].get(klass)
+      end
+
+      def expand_with_node(name, klass)
+        expand_with(:node => @context[:node].move_to(name, klass))
+      end
+
+      # def context_with_node(name, klass)
+      #   context = @context.dup
+      #   context[:node] = context[:node].move_to(name, klass)
+      # end
+
+      def var
+        return @var if @var
+        if node.name =~ /^var(\d+)$/
+          @var = "var#{$1.to_i + 1}"
+        else
+          @var = "var1"
+        end
+      end
+    end # Context
+  end # Process
+end # Zafu

data/lib/zafu/process/html.rb

@@ -0,0 +1,168 @@
+module Zafu
+  module Process
+    module HTML
+      attr_accessor :html_tag, :html_tag_params, :name, :sub_do
+
+      # Replace the 'original' element in the included template with our new version.
+      def replace_with(new_obj)
+        super
+        html_tag_params    = new_obj.html_tag_params
+        [:class, :id].each do |sym|
+          html_tag_params[sym] = new_obj.params[sym] if new_obj.params.include?(sym)
+        end
+        @markup.tag = new_obj.html_tag || @markup.tag
+        @markup.params.merge!(html_tag_params)
+        if new_obj.params[:method]
+          @method   = new_obj.params[:method] if new_obj.params[:method]
+        elsif new_obj.sub_do
+          @method = 'void'
+        end
+      end
+
+      # Pass the caller's 'html_tag' and 'html_tag_params' to the included part.
+      def include_part(obj)
+        obj.html_tag = @markup.tag || obj.html_tag
+        obj.html_tag_params = !@markup.params.empty? ? @markup.params : obj.html_tag_params
+        @markup.tag = nil
+        @markup.params = {}
+        super(obj)
+      end
+
+      def empty?
+        super && @markup.params == {} && @markup.tag.nil?
+      end
+
+      def before_process
+        return unless super
+        @markup.done = false
+        unless @markup.tag
+          if @markup.tag = @params.delete(:tag)
+            @markup.params = {}
+            [:id, :class].each do |k|
+              next unless @params[k]
+              @markup.params[k] = @params.delete(k)
+            end
+          end
+        end
+        # Translate dynamic params such as <tt>class='#{visitor.lang}'</tt> in the context
+        # of the current parser
+        @markup.compile_params(self)
+
+        # [each] is run many times with different roles. Some of these change html_tag_params.
+        @markup_bak = @markup.dup
+        true
+      end
+
+      def after_process(text)
+        res = @markup.wrap(super)
+        @markup = @markup_bak
+        res
+      end
+
+      def inspect
+        @markup.done = false
+        res = super
+        if @markup.tag
+          if res =~ /\A\[(\w+)(.*)\/\]\Z/m
+            res = "[#{$1}#{$2}]<#{@markup.tag}/>[/#{$1}]"
+          elsif res =~ /\A\[([^\]]+)\](.*)\[\/(\w+)\]\Z/m
+            res = "[#{$1}]#{render_html_tag($2)}[/#{$3}]"
+          end
+        end
+        res
+      end
+
+      def r_ignore
+        @markup.done = true
+        ''
+      end
+
+      alias r_ r_ignore
+
+      def r_rename_asset
+        return expand_with unless @markup.tag
+        case @markup.tag
+        when 'link'
+          key = :href
+          if @params[:rel].downcase == 'stylesheet'
+            type = :stylesheet
+          else
+            type = :link
+          end
+        when 'style'
+          @markup.done = true
+          return expand_with.gsub(/url\(('|")(.*?)\1\)/) do
+            if $2[0..6] == 'http://'
+              $&
+            else
+              quote   = $1
+              new_src = helper.send(:template_url_for_asset, :base_path=>@options[:base_path], :src => $2)
+              "url(#{quote}#{new_src}#{quote})"
+            end
+          end
+        else
+          key = :src
+          type = @markup.tag.to_sym
+        end
+
+        src = @params[key]
+        if src && src[0..0] != '/' && src[0..6] != 'http://'
+          @params[key] = helper.send(:template_url_for_asset, :src => src, :base_path => @options[:base_path], :type => type)
+        end
+
+        res   = "<#{@markup.tag}#{params_to_html(@params)}"
+        @markup.done = true
+        inner = expand_with
+        if inner == ''
+          res + "/>"
+        else
+          res + ">#{inner}"
+        end
+      end
+
+      def r_form
+        res   = "<#{@markup.tag}#{params_to_html(@params)}"
+        @markup.done = true
+        inner = expand_with
+        if inner == ''
+          res + "/>"
+        else
+          res + ">#{inner}"
+        end
+      end
+
+      def r_select
+        res   = "<#{@markup.tag}#{params_to_html(@params)}"
+        @markup.done = true
+        inner = expand_with
+        if inner == ''
+          res + "></#{@markup.tag}>"
+        else
+          res + ">#{inner}"
+        end
+      end
+
+      def r_input
+        res   = "<#{@markup.tag}#{params_to_html(@params)}"
+        @markup.done = true
+        inner = expand_with
+        if inner == ''
+          res + "/>"
+        else
+          res + ">#{inner}"
+        end
+      end
+
+      def r_textarea
+        res   = "<#{@markup.tag}#{params_to_html(@params)}"
+        @markup.done = true
+        inner = expand_with
+        if inner == ''
+          res + "/>"
+        else
+          res + ">#{inner}"
+        end
+      end
+    end # HTML
+  end # Process
+end # Zafu