zafu 0.5.0 → 0.6.0

data/History.txt

@@ -1,3 +1,14 @@
+== 0.6.0 2010-05-27
+
+* 3 major enhancements
+  * Added rubyless_class_scope to filter evaluation on class type.
+  * Started to move tests from Zena.
+  * Added 'up(klass)' method.
+
+* 1 minor enhancement
+  * Added 'has_param' to the Markup object.
+  * Added 'prepend_param'.
+
 == 0.5.0 2010-03-21
 
 * 6 major enhancement

data/Rakefile

@@ -13,7 +13,8 @@ begin
     gem.homepage = "http://zenadmin.org/zafu"
     gem.authors = ["Gaspard Bucher"]
     gem.add_development_dependency "shoulda", ">= 0"
-    gem.add_dependency "rubyless", ">= 0.4.0"
+    gem.add_development_dependency "yamltest", ">= 0.5.0"
+    gem.add_dependency "rubyless", ">= 0.5.0"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/lib/zafu/all.rb

@@ -1,17 +1,19 @@
 require 'zafu/parsing_rules'
-#  require 'zafu/process/ajax'
+require 'zafu/process/ajax'
 require 'zafu/process/html'
-require 'zafu/process/ruby_less'
+require 'zafu/process/ruby_less_processing'
 require 'zafu/process/context'
 require 'zafu/process/conditional'
+require 'zafu/process/forms'
 
 module Zafu
   All = [
     Zafu::ParsingRules,
-#    Zafu::Process::Ajax,
     Zafu::Process::HTML,
     Zafu::Process::Context,
     Zafu::Process::Conditional,
-    Zafu::Process::RubyLess
+    Zafu::Process::RubyLessProcessing,
+    Zafu::Process::Ajax,
+    Zafu::Process::Forms,
   ]
 end

data/lib/zafu/controller_methods.rb

@@ -1,7 +1,7 @@
 module Zafu
   module ControllerMethods
     def self.included(base)
-      base.helper_method :zafu_context, :get_template_text, :template_url_for_asset
+      base.helper Common
       if RAILS_ENV == 'development'
         base.class_eval do
           def render_for_file_with_rebuild(template_path, status = nil, layout = nil, locals = {}) #:nodoc:
@@ -24,26 +24,35 @@ module Zafu
       zafu_context[:node] = Zafu::NodeContext.new(name, klass)
     end
 
-    def zafu_context
-      @zafu_context ||= {}
-    end
+    module Common
+      def zafu_context
+        @zafu_context ||= {}
+      end
 
-    # This method should return the template for a given 'src' and
-    # 'base_path'.
-    def get_template_text(path, base_path)
-      [path, "#{base_path}/#{path}"].each do |p|
-        begin
-          t = self.view_paths.find_template(p, 'html') # FIXME: format ?
-        rescue ActionView::MissingTemplate
-          t = nil
+      # Quote for html attributes (field quote). There might be a better rails alternative to this.
+      def fquote(text)
+        text.to_s.gsub("'",''')
+      end
+
+      # This method should return the template for a given 'src' and
+      # 'base_path'.
+      def get_template_text(path, base_path)
+        [path, "#{base_path}/#{path}"].each do |p|
+          begin
+            t = self.view_paths.find_template(p, 'html') # FIXME: format ?
+          rescue ActionView::MissingTemplate
+            t = nil
+          end
+          return [t.source, t.path, t.base_path] if t
         end
-        return [t.source, t.path, t.base_path] if t
+        nil
       end
-      nil
-    end
 
-    def template_url_for_asset(opts)
-      opts[:src]
-    end
+      def template_url_for_asset(opts)
+        opts[:src]
+      end
+    end # Common
+
+    include Common
   end
 end

data/lib/zafu/info.rb

@@ -1,4 +1,4 @@
 module Zafu
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end
 

data/lib/zafu/markup.rb

@@ -1,9 +1,15 @@
+require 'zafu/ordered_hash'
+
 module Zafu
   # A Markup object is used to hold information on the tag used (<li>), it's parameters (.. class='xxx') and
   # indentation.
   class Markup
-    EMPTY_TAGS   = %w{meta input}
-    STEAL_PARAMS = [:class, :id, :style]
+    EMPTY_TAGS   = %w{meta input link}
+    STEAL_PARAMS = {
+      'link'   => [:href, :charset, :rel, :type, :media, :rev, :target],
+      'script' => [:type, :charset, :defer],
+      :other   => [:class, :id, :style],
+    }
 
     # Tag used ("li" for example). The tag can be nil (no tag).
     attr_accessor :tag
@@ -23,9 +29,9 @@ module Zafu
       # Parse parameters into a hash. This parsing supports multiple values for one key by creating additional keys:
       # <tag do='hello' or='goodbye' or='gotohell'> creates the hash {:do=>'hello', :or=>'goodbye', :or1=>'gotohell'}
       def parse_params(text)
-        return {} unless text
+        return OrderedHash.new unless text
         return text if text.kind_of?(Hash)
-        params = {}
+        params = OrderedHash.new
         rest = text.strip
         while (rest != '')
           if rest =~ /(.+?)=/
@@ -60,8 +66,8 @@ module Zafu
     def initialize(tag)
       @done       = false
       @tag        = tag
-      @params     = {}
-      @dyn_params = {}
+      @params     = OrderedHash.new
+      @dyn_params = OrderedHash.new
     end
 
     # Set params either using a string (like "alt='time passes' class='zen'")
@@ -73,11 +79,15 @@ module Zafu
       end
     end
 
+    # Another way to set dynamic params (the argument must be a hash).
+    def dyn_params=(h)
+      set_dyn_params(h)
+    end
+
     # Steal html parameters from an existing hash (the stolen parameters are removed
     # from the argument)
     def steal_html_params_from(p)
-      @params ||= {}
-      STEAL_PARAMS.each do |k|
+      steal_keys.each do |k|
         next unless p[k]
         @params[k] = p.delete(k)
       end
@@ -100,18 +110,38 @@ module Zafu
 
     # Set dynamic html parameters.
     def set_dyn_params(hash)
-      hash.keys.each do |k|
-        @params.delete(k)
+      hash.each do |k,v|
+        set_dyn_param(k, v)
       end
-      @dyn_params.merge!(hash)
+    end
+
+    # Set dynamic html parameters.
+    def set_dyn_param(key, value)
+      @params.delete(key)
+      @dyn_params[key] = value
     end
 
     # Set static html parameters.
     def set_params(hash)
-      hash.keys.each do |k|
-        @dyn_params.delete(k)
+      hash.each do |k,v|
+        set_param(k, v)
+      end
+    end
+
+    # Set static html parameters.
+    def set_param(key, value)
+      @dyn_params.delete(key)
+      @params[key] = value
+    end
+
+    def prepend_param(key, value)
+      if prev_value = @dyn_params[key]
+        @dyn_params[key] = "#{value} #{prev_value}"
+      elsif prev_value = @params[key]
+        @params[key] = "#{value} #{prev_value}"
+      else
+        @params[key] = value
       end
-      @params.merge!(hash)
     end
 
     def append_param(key, value)
@@ -124,11 +154,23 @@ module Zafu
       end
     end
 
-    def append_dyn_param(key, value)
+    def prepend_dyn_param(key, value, conditional = false)
+      spacer = conditional ? '' : ' '
       if prev_value = @params.delete(key)
-        @dyn_params[key] = "#{prev_value} #{value}"
+        @dyn_params[key] = "#{value}#{spacer}#{prev_value}"
       elsif prev_value = @dyn_params[key]
-        @dyn_params[key] = "#{prev_value} #{value}"
+        @dyn_params[key] = "#{value}#{spacer}#{prev_value}"
+      else
+        @dyn_params[key] = value
+      end
+    end
+
+    def append_dyn_param(key, value, conditional = false)
+      spacer = conditional ? '' : ' '
+      if prev_value = @params.delete(key)
+        @dyn_params[key] = "#{prev_value}#{spacer}#{value}"
+      elsif prev_value = @dyn_params[key]
+        @dyn_params[key] = "#{prev_value}#{spacer}#{value}"
       else
         @dyn_params[key] = value
       end
@@ -140,10 +182,27 @@ module Zafu
       dyn_params[:id] = erb_id
     end
 
+    # Return true if the given key exists in params or dyn_params.
+    def has_param?(key)
+      params[key] || dyn_params[key]
+    end
+
+    # Duplicate markup and make sure params and dyn_params are duplicated as well.
+    def dup
+      markup = Markup.new(@tag)
+      markup.params = @params.dup
+      markup.dyn_params = @dyn_params.dup
+      markup
+    end
+
     # Wrap the given text with our tag. If 'append' is not empty, append the text
     # after the tag parameters: <li class='foo'[APPEND HERE]>text</li>.
     def wrap(text, *append)
       return text if @done
+      if dyn_params[:id]
+        @tag ||= 'div'
+      end
+
       append ||= []
       if @tag
         if text.blank? && EMPTY_TAGS.include?(@tag)
@@ -159,15 +218,14 @@ module Zafu
       (@space_before || '') + res + (@space_after || '')
     end
 
+    def steal_keys
+      (STEAL_PARAMS[@tag] || []) + STEAL_PARAMS[:other]
+    end
+
     private
       def params_to_html
         para = []
-        keys = []
-
-        @dyn_params.each do |k,v|
-          keys << k
-          para << " #{k}='#{v}'"
-        end
+        keys = @dyn_params.keys
 
         @params.each do |k,v|
           next if keys.include?(k)
@@ -179,8 +237,12 @@ module Zafu
           end
         end
 
-        # we sort so that the output is always the same (needed for testing)
-        para.sort.join('')
+        @dyn_params.each do |k,v|
+          para << " #{k}='#{v}'"
+        end
+
+        para
       end
+
   end
 end

data/lib/zafu/node_context.rb

@@ -3,6 +3,9 @@ module Zafu
     # The name of the variable halding the current object or list ("@node", "var1")
     attr_reader :name
 
+    # The previous NodeContext
+    attr_reader :up
+
     # The type of object contained in the current context (Node, Page, Image)
     attr_reader :klass
 
@@ -27,16 +30,31 @@ module Zafu
     # Return true if the NodeContext represents an element of the given type. We use 'will_be' because
     # it is equivalent to 'is_a', but for future objects (during rendering).
     def will_be?(type)
-      klass.ancestors.include?(type)
+      klass.kind_of?(Array) ? klass.first.ancestors.include?(type) : klass.ancestors.include?(type)
     end
 
     # Return a new node context that corresponds to the current object when rendered alone (in an ajax response or
     # from a direct 'show' in a controller). The returned node context has no parent (up is nil).
     # The convention is to use the class of the current object to build this name.
-    def as_main
+    # You can also use an 'after_class' parameter to move up in the current object's class hierarchy (see #master_class).
+    def as_main(after_class = nil)
+      klass = after_class ? master_class(after_class) : self.klass
       NodeContext.new("@#{klass.to_s.underscore}", klass)
     end
 
+    # Find the class just afer 'after_class' in the class hierarchy.
+    # For example if we have Dog < Mamal < Animal < Creature,
+    # master_class(Creature) would return Animal
+    def master_class(after_class)
+      klass = self.klass
+      klass = klass.first if klass.kind_of?(Array)
+      begin
+        up = klass.superclass
+        return klass if up == after_class
+      end while klass = up
+      return self.klass
+    end
+
     # Generate a unique DOM id for this element based on dom_scopes defined in parent contexts.
     def dom_id
       @dom_id ||= begin
@@ -49,7 +67,7 @@ module Zafu
     end
 
     # This holds the current context's unique name if it has it's own or one from the hierarchy. If
-    # none is found, it builds one... How ?
+    # none is found, it builds one.
     def dom_prefix
       @dom_prefix || (@up ? @up.dom_prefix : nil)
     end
@@ -62,7 +80,7 @@ module Zafu
 
     def get(klass)
       if list_context?
-        if self.klass.first.ancestors.include?(klass)
+        if klass <= self.klass.first
           NodeContext.new("#{self.name}.first", self.klass.first)
         elsif @up
           @up.get(klass)
@@ -78,10 +96,36 @@ module Zafu
       end
     end
 
+    def up(klass = nil)
+      klass ? @up.get(klass) : @up
+    end
+
+    # Return true if the current klass is an Array.
     def list_context?
       klass.kind_of?(Array)
     end
 
+    # Return the name of the current class with underscores like 'sub_page'.
+    def underscore
+      class_name.to_s.underscore
+    end
+
+    # Return the class name or the superclass name if the current class is an anonymous class.
+    # FIXME: just use klass.to_s (so that we can do clever things with 'to_s')
+    def class_name
+      if list_context?
+        klass = @klass.first
+        "[#{(klass.name.blank? ? klass.superclass : klass).name}]"
+      else
+        (@klass.name.blank? ? @klass.superclass : @klass).name
+      end
+    end
+
+    # Return the name to use for input fields
+    def form_name
+      @form_name ||= master_class(ActiveRecord::Base).name.underscore
+    end
+
     protected
       # List of scopes defined in ancestry (used to generate dom_id).
       def dom_scopes

data/lib/zafu/ordered_hash.rb

@@ -0,0 +1,47 @@
+module Zafu
+
+  if RUBY_VERSION.split('.')[0..1].join('.').to_f > 1.8
+    OrderedHash = Hash
+  else
+    class OrderedHash < Hash
+
+      def []=(k, v)
+        get_keys << k unless get_keys.include?(k)
+        super
+      end
+
+      def merge!(hash)
+        hash.keys.each do |k|
+          get_keys << k unless get_keys.include?(k)
+        end
+        super
+      end
+
+      alias o_keys keys
+      def get_keys
+        @keys ||= o_keys
+      end
+
+      def keys
+        get_keys.dup
+      end
+
+      def each
+        keys.each do |k|
+          yield(k, self[k])
+        end
+      end
+
+      def delete(k)
+        get_keys.delete(k)
+        super
+      end
+
+      def dup
+        copy = super
+        copy.instance_variable_set(:@keys, keys)
+        copy
+      end
+    end
+  end
+end