zena 1.2.1 → 1.2.2

data/lib/zafu/process/conditional.rb

@@ -0,0 +1,92 @@
+module Zafu
+  module Process
+    # This module manages conditional rendering (if, else, elsif, case, when).
+    module Conditional
+      def r_if(cond = nil)
+        cond ||= get_condition
+        return unless cond
+        expand_if(cond)
+      end
+
+      def r_case
+        r_if('false')
+      end
+
+      def r_else
+        r_elsif('true')
+      end
+
+      def r_when
+        r_elsif
+      end
+
+      def r_elsif(cond = nil)
+        return '' unless @context[:in_if]
+        cond ||= get_condition
+        return unless cond
+
+        res = expand_with(:in_if => false, :markup => nil)
+
+        # We use 'elsif' just in case there are more then one 'else' clause
+        if markup = @context[:markup]
+          if @markup.tag.blank?
+            # Copy markup tag
+            @markup.tag = markup.tag
+            @markup.steal_html_params_from(@params)
+            markup.params.each do |k, v|
+              next if @markup.params[k]
+              @markup.set_param(k, v)
+            end
+
+            markup.dyn_params.each do |k, v|
+              next if @markup.params[k] || @markup.dyn_params[k]
+              @markup.set_dyn_param(k, v)
+            end
+            inner = wrap(res)
+          else
+            markup.done = false
+            # Wrap with both markup (ours and the else/elsif clause).
+            inner = markup.wrap(wrap(res))
+          end
+          out "<% elsif #{cond} %>#{inner}" # do not propagate
+        else
+          #@markup.done = true # never wrap else/elsif clause
+          out "<% elsif #{cond} %>#{res}" # do not propagate
+        end
+      end
+
+      # Expand blocks with conditional processing enabled (else, elsif, etc).
+      #
+      # ==== Parameters
+      #
+      # * +condition+ - ruby condition for the conditional execution.
+      # * +new_node_context+ - (optional) new node context to enter if the clause succeeds.
+      # * +alt_markup+ - (optional) alternative markup to use for the 'else', 'elsif' clauses.
+      def expand_if(condition, new_node_context = self.node, alt_markup = @markup)
+        res = ""
+        res << "<% if #{condition} %>"
+        with_context(:node => new_node_context) do
+          res << wrap(expand_with)
+        end
+
+        only = method == 'case' ? %r{^[A-Z]|else|elsif|when} : %w{else elsif when}
+        res << expand_with(:in_if => true, :only => only, :markup => alt_markup)
+        res << "<% end %>"
+        res
+      end
+
+      private
+        def get_condition
+          if in_tag = @params[:in]
+            if in_tag == 'form' && @context[:make_form]
+              'true'
+            else
+              ancestor(in_tag) ? 'true' : 'false'
+            end
+          else
+            get_attribute_or_eval(false)
+          end
+        end
+    end # Context
+  end # Process
+end # Zafu

data/lib/zafu/process/context.rb

@@ -0,0 +1,186 @@
+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.list_context?
+          if @params[:alt_class] || @params[:join]
+            out "<% #{var}_max_index = #{node}.size - 1 %>" if @params[:alt_reverse]
+            out "<% #{node}.each_with_index do |#{var},#{var}_index| %>"
+
+            if join = @params[:join]
+              join = RubyLess.translate_string(self, join)
+              out "<%= #{var}_index > 0 ? #{join} : '' %>"
+            end
+
+            if alt_class = @params[:alt_class]
+              alt_class = RubyLess.translate_string(self, alt_class)
+              alt_test = @params[:alt_reverse] == 'true' ? "(#{var}_max_index - #{var}_index) % 2 != 0" : "#{var}_index % 2 != 0"
+
+              alt_var = get_var_name('set_var', 'alt_class')
+              set_context_var('set_var', 'alt_class', RubyLess::TypedString.new(alt_var, :class => String))
+              out "<% #{alt_var} = #{alt_test} ? #{alt_class} : '' %>"
+
+              if @markup.tag
+                @markup.append_dyn_param(:class, "<%= #{alt_var} %>")
+              else
+                # Just declare 'alt_class'
+              end
+            end
+          else
+            out "<% #{node}.each do |#{var}| %>"
+          end
+
+          raw_dom_prefix = node.raw_dom_prefix
+
+          with_context(:node => node.move_to(var, node.klass.first, :query => node.opts[:query])) do
+            # We pass the :query option for RubyLess resolution by using the QueryBuilder finder
+
+            steal_and_eval_html_params_for(@markup, @params)
+            # The id set here should be used as prefix for sub-nodes to ensure uniqueness of generated DOM ids
+            if node.list_context?
+              # we are still in a list (example: previous context was [[Node]], current is [Node])
+            else
+              # Change dom_prefix if it isn't our own (inherited).
+              node.dom_prefix = dom_name unless raw_dom_prefix
+              node.propagate_dom_scope!
+
+              if need_dom_id?
+                @markup.set_id(node.dom_id)
+              end
+            end
+
+            out wrap(expand_with)
+          end
+          out "<% end %>"
+        else
+          out expand_with
+        end
+
+        # We need to return true for Ajax 'make_form'
+        true
+      end
+
+      def helper
+        @context[:helper]
+      end
+
+      # Return true if we need to insert the dom id for this element. This method is overwritten in Ajax.
+      def need_dom_id?
+        false
+      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
+
+      # Store some contextual value / variable inside a named group. This should be
+      # used to avoid key clashes between different types of elements to store.
+      def set_context_var(group, key, obj, context = @context)
+        context["#{group}::#{key}"] = obj
+      end
+
+      # Retrieve a value from a given contextual group. The value must have been
+      # previously set with 'set_context_var' somewhere in the hierarchy.
+      def get_context_var(group, key, context = @context)
+        context["#{group}::#{key}"]
+      end
+
+      # Return a new context without contextual variables.
+      def context_without_vars
+        context = @context.dup
+        context.keys.each do |k|
+          context.delete(k) if k.kind_of?(String)
+        end
+        context
+      end
+
+      # Expand blocks in a new context.
+      # This method is partly overwriten in Ajax
+      def expand_with_finder(finder)
+        if finder[:nil]
+          open_node_context(finder, :form => nil) do # do not propagate :form
+            expand_if("#{var} = #{finder[:method]}", node.move_to(var, finder[:class], finder.merge(:nil => false)))
+          end
+        else
+          res = ''
+          res << "<% #{var} = #{finder[:method]} %>"
+          open_node_context(finder, :node => node.move_to(var, finder[:class], finder), :form => nil) do
+            res << wrap(expand_with)
+          end
+          res
+        end
+      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
+
+      # This method is called when we enter a new node context
+      def node_context_vars(finder)
+        # do nothing (this is a hook for other modules like QueryBuilder and RubyLess)
+        {}
+      end
+
+      # Get a variable name and store the name in context variables for the given group.
+      #
+      # ==== Parameters
+      #
+      # * +group_name+  - name of the variable context group
+      # * +wanted_name+ - wanted variable name (used as key to get real var back later with #get_context_var)
+      # * +context+ - (optional) can be used if we do not want to store the variable definition in the current context
+      #
+      def get_var_name(group_name, wanted_name, context = @context)
+        secure_name = wanted_name.gsub(/[^a-zA-Z0-9]/,'')
+        name = "_z#{secure_name}"
+        i    = 0
+        while get_context_var('var', name, context)
+          i += 1
+          name = "_z#{secure_name}#{i}"
+        end
+        set_context_var('var', name, true)
+        set_context_var(group_name, wanted_name, name)
+        name
+      end
+
+      # Change context for a given scope.
+      def with_context(cont, merge = true)
+        raise "Block missing" unless block_given?
+        cont_bak = @context
+          if merge
+            @context = @context.merge(cont)
+          else
+            @context = cont
+          end
+          res = yield
+        @context = cont_bak
+        res
+      end
+
+      # This should be called when we enter a new node context so that the proper hooks are
+      # triggered (insertion of contextual variables).
+      def open_node_context(finder, cont = {})
+        sub_context = node_context_vars(finder).merge(cont)
+
+        with_context(sub_context) do
+          yield
+        end
+      end
+    end # Context
+  end # Process
+end # Zafu

data/lib/zafu/process/forms.rb

@@ -0,0 +1,143 @@
+module Zafu
+  module Process
+    module Forms
+      def self.included(base)
+        base.expander :make_form
+      end
+
+      def r_form
+        if node.dom_prefix
+          fnode = node
+        else
+          fnode = node.dup
+          fnode.dom_prefix = dom_name
+        end
+        with_context(:node => fnode) do
+          
+          unless @params[:on].nil? || @params[:on].split(',').include?(@context[:ajax_action])
+            return ''
+          end
+
+          return parser_error('Cannot render update form in list context.') if node.list_context?
+
+          options = form_options
+
+          @markup.set_id(options[:id]) if options[:id]
+          @markup.set_param(:style, options[:style]) if options[:style]
+
+          if descendant('form_tag')
+            # We have a specific place to insert our form
+            out expand_with(:form_options => options, :form => self)
+          else
+            r_form_tag(options)
+          end
+        end
+      end
+
+      def r_form_tag(options = @context[:form_options])
+        form_tag(options) do |opts|
+          # Render error messages tag
+          form_error_messages(opts[:form_helper])
+
+          # Render form elements
+          out expand_with(opts)
+
+          # Render hidden fields (these must go after normal elements so that focusFirstElement works)
+          hidden_fields = form_hidden_fields(options)
+
+          out "<div class='hidden'>"
+          hidden_fields.each do |k,v|
+            if v.kind_of?(String)
+              v = "'#{v}'" unless v.kind_of?(String) && ['"', "'"].include?(v[0..0])
+              out "<input type='hidden' name='#{k}' value=#{v}/>"
+            elsif v.kind_of?(Array)
+              # We use ['ffff'] to indicate that the content is already escaped and ready for ERB.
+              out v.first
+            end
+          end
+          out '</div>'
+        end
+      end
+
+      private
+        def make_form
+          return nil unless @context[:make_form]
+
+          if method == 'each' || method == 'block'
+            r_form
+          else
+            nil
+          end
+        end
+
+        # Return id, style, form and cancel parts of the form.
+        def form_options
+          opts = {}
+
+          # Do we need this ?
+          # opts[:klass] = node.master_class(ActiveRecord::Base).to_s
+
+          if @context[:in_add]
+            opts[:id]    = "#{node.dom_prefix}_add"
+            opts[:style] = 'display:none;'
+          elsif @markup.tag == 'table'
+            # the normal id goes to the form wrapping the table
+            opts[:id]    = "#{node.dom_prefix}_tbl"
+            form_id      = node.dom_prefix
+          end
+
+          form_id ||= "#{node.dom_prefix}_form_t"
+          if @context[:template_url]
+            opts[:form_tag]    = "<% remote_form_for(:#{node.form_name}, #{node}, :html => {:id => #{form_id.inspect}}) do |f| %>"
+            opts[:form_helper] = 'f'
+          else
+            opts[:form_tag]    = "<% form_for(:#{node.form_name}, #{node}, :html => {:id => #{form_id.inspect}}) do |f| %>"
+            opts[:form_helper] = 'f'
+          end
+          opts[:form_prefix] = node.dom_prefix || dom_name
+          opts
+        end
+
+        # Return hidden fields that need to be inserted in the form.
+        def form_hidden_fields(opts)
+          if t_url = @context[:template_url]
+            {'t_url' => t_url}
+          else
+            {}
+          end
+        end
+
+        # Render the 'form' tag and set expansion context.
+        def form_tag(options)
+          opts = options.dup
+
+          if descendant('cancel') || descendant('edit')
+            # Pass 'form_cancel' content to expand_with (already in options).
+          else
+            # Insert cancel before form
+            out opts.delete(:form_cancel).to_s
+          end
+
+          # form_for ... do |f|
+          out opts.delete(:form_tag)
+            # f.xxx
+            if markup.tag == 'table'
+              # Avoid <table><form> (invalid HTML)
+              bak = @result
+              @result = ''
+              yield(opts.merge(:in_form => true))
+              @result = bak + markup.wrap(@result)
+            else
+              yield(opts.merge(:in_form => true))
+            end
+          # close form
+          out opts[:form_helper] ? "<% end %>" : '</form>'
+        end
+
+        def form_error_messages(f)
+          out "<%= #{f}.error_messages %>"
+        end
+
+    end # Forms
+  end # Process
+end # Zafu

data/lib/zafu/process/html.rb

@@ -0,0 +1,186 @@
+module Zafu
+  module Process
+    module HTML
+      SAFE_SRC_REGEX = %r{\A/[^\.]+\.[a-zA-Z]+\Z}
+      def self.included(base)
+        base.wrap  :wrap_html
+      end
+
+      # Replace the 'original' element in the included template with our new version.
+      def replace_with(new_obj)
+        super
+        # [self = original_element]. Replace @markup with content of the new_obj (<ul do='with'>...)
+        if new_obj.markup.tag
+          @markup.tag = new_obj.markup.tag
+        else
+          # Steal 'class' param
+          @markup.steal_html_params_from(new_obj.params)
+        end
+
+        @markup.params.merge!(new_obj.markup.params)
+
+        # We do not have to merge dyn_params since these are compiled before processing (and we are in
+        # the pre-processor)
+
+        if new_obj.params[:method]
+          @method   = new_obj.params[:method]
+        elsif new_obj.sub_do
+          @method = 'void'
+        end
+      end
+
+      # Pass the caller's 'markup' to the included part.
+      def include_part(obj)
+        if @markup.tag
+          obj.markup = @markup.dup
+        end
+        @markup.tag = nil
+
+        if sub_do
+          obj.method = @blocks.first.method
+          obj.params = @blocks.first.params
+        elsif params[:method]
+          obj.method = params[:method]
+        end
+        super(obj)
+      end
+
+      def empty?
+        super && @markup.params == {} && @markup.tag.nil?
+      end
+
+      def compile_html_params
+        return if @markup.done
+        unless @markup.tag
+          if @markup.tag = @params.delete(:tag)
+            @markup.steal_html_params_from(@params)
+          end
+        end
+
+        # Translate dynamic params such as <tt>class='#{visitor.lang}'</tt> in the context
+        # of the current parser
+        @markup.compile_params(self)
+      end
+
+      def wrap_html(text)
+        compile_html_params
+        @markup.wrap(text)
+      end
+
+      #def restore_markup
+      #  # restore @markup
+      #  @markup = @markup_bak
+      #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}]#{@markup.wrap($2)}[/#{$3}]"
+          end
+        end
+        res
+      end
+
+      def r_ignore
+        @markup.done = true
+        ''
+      end
+
+      def r_rename_asset
+        return expand_with unless @markup.tag
+        case @markup.tag
+        when 'link'
+          key = :href
+          return parser_error("Missing 'rel' parameter.") unless rel = @params[:rel]
+          return parser_error("Missing 'href' parameter.") unless @params[:href]
+          if rel.downcase == 'stylesheet'
+            type = :stylesheet
+          else
+            type = :link
+          end
+        when 'style'
+          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.delete(key)
+        if src && src[0..7] != 'http://'
+          if new_value = helper.send(:template_url_for_asset, :src => src, :base_path => @options[:base_path], :type => type)
+          elsif src =~ SAFE_SRC_REGEX
+            fullpath = "#{SITES_ROOT}#{current_site.public_path}#{src}"
+            if File.exist?(fullpath) && File.stat(fullpath)
+              src = "#{src}?#{File.mtime(fullpath).to_i}"
+            end
+          end
+          @markup.params[key] = new_value.blank? ? src : new_value
+        end
+
+        expand_with
+      end
+
+      def steal_and_eval_html_params_for(markup, params)
+        markup.steal_keys.each do |key|
+          next unless value = params.delete(key)
+          append_markup_attr(markup, key, value)
+        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