zafu 0.5.0

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+.DS_Store

data/History.txt

@@ -0,0 +1,9 @@
+== 0.5.0 2010-03-21
+
+* 6 major enhancement
+  * Initial release.
+  * Uses helpers to resolve methods.
+  * Compiles 'html' with rubyless declarations.
+  * Guesses main ivar from view.
+  * Tries to resolve method by adding current node parameter.
+  * Added basic conditional execution with 'else' and dummy 'if' clauses.

data/README.rdoc

@@ -0,0 +1,56 @@
+= zafu
+
+* http://zenadmin.org/en/zafu
+
+== DESCRIPTION:
+
+Provides a powerful templating language based on xhtml for rails.
+
+== FEATURES/PROBLEMS:
+
+* The current implementation of zafu is in zena's repository (http://zenadmin.org).
+  The content will be moved here as soon as zafu works as a standalone gem.
+
+== SYNOPSIS:
+
+  <ul do='images where name like "%flower%" in site'>
+    <li do='each'>
+      <r:img/>
+      <r:link/>
+    </li>
+  </ul>
+
+== REQUIREMENTS:
+
+* FIX (not very clear yet)
+* yamltest
+
+== INSTALL:
+
+* !! not ready for deployment, please do not install !!
+* sudo gem install zafu
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007-2009 Gaspard Bucher
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+require(File.join(File.dirname(__FILE__), 'lib/zafu/info'))
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.version = Zafu::VERSION
+    gem.name = 'zafu'
+    gem.summary = %Q{Provides a powerful templating language based on xhtml for rails}
+    gem.description = %Q{Provides a powerful templating language based on xhtml for rails}
+    gem.email = "gaspard@teti.ch"
+    gem.homepage = "http://zenadmin.org/zafu"
+    gem.authors = ["Gaspard Bucher"]
+    gem.add_development_dependency "shoulda", ">= 0"
+    gem.add_dependency "rubyless", ">= 0.4.0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "zafu #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/zafu/all.rb

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

data/lib/zafu/compiler.rb

@@ -0,0 +1,7 @@
+require 'zafu/parser'
+require 'zafu/node_context'
+require 'zafu/all'
+
+module Zafu
+  Compiler = Zafu.parser_with_rules(Zafu::All)
+end

data/lib/zafu/controller_methods.rb

@@ -0,0 +1,49 @@
+module Zafu
+  module ControllerMethods
+    def self.included(base)
+      base.helper_method :zafu_context, :get_template_text, :template_url_for_asset
+      if RAILS_ENV == 'development'
+        base.class_eval do
+          def render_for_file_with_rebuild(template_path, status = nil, layout = nil, locals = {}) #:nodoc:
+            path = template_path.respond_to?(:path_without_format_and_extension) ? template_path.path_without_format_and_extension : template_path
+            logger.info("Rendering #{path}" + (status ? " (#{status})" : '')) if logger
+            # if params[:rebuild] == 'true'
+              t = self.view_paths.find_template(template_path, 'html')
+              t.previously_last_modified = nil
+            # end
+            render_for_text @template.render(:file => template_path, :locals => locals, :layout => layout), status
+          rescue => err
+            puts err.backtrace.join("\n")
+          end
+          alias_method_chain :render_for_file, :rebuild
+        end
+      end
+    end
+
+    def zafu_node(name, klass)
+      zafu_context[:node] = Zafu::NodeContext.new(name, klass)
+    end
+
+    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
+        end
+        return [t.source, t.path, t.base_path] if t
+      end
+      nil
+    end
+
+    def template_url_for_asset(opts)
+      opts[:src]
+    end
+  end
+end

data/lib/zafu/handler.rb

@@ -0,0 +1,57 @@
+require 'zafu/parser'
+require 'zafu/markup'
+require 'zafu/node_context'
+require 'zafu/template'
+
+module Zafu
+  class Handler < ActionView::TemplateHandler
+    include ActionView::TemplateHandlers::Compilable
+
+    def compile(template)
+      @template = template
+      helper   = Thread.current[:view]
+      if !helper.respond_to?(:zafu_context)
+        raise Exception.new("Please add \"include Zafu::ControllerMethods\" into your ApplicationController for zafu to work properly.")
+      end
+      ast = Zafu::Template.new(template, self)
+      context = helper.zafu_context.merge(:helper => helper)
+      context[:node] ||= get_zafu_node_from_view(helper)
+      rb = ast.to_ruby('@output_buffer', context)
+      ";@erb = %q{#{ast.to_erb(context)}};#{rb}"
+    end
+
+    def get_template_text(path, base_path)
+      if path == @template.path && base_path.nil?
+        [@template.source, @template.path, @template.base_path]
+      else
+        Thread.current[:view].get_template_text(path, base_path)
+      end
+    end
+
+    private
+      def get_zafu_node_from_view(view)
+        controller = view.controller
+        if controller.class.to_s =~ /\A([A-Z]\w+?)s?[A-Z]/
+          ivar = "@#{$1.downcase}"
+          if var = controller.instance_variable_get(ivar.to_sym)
+            name  = ivar
+            klass = var.class
+          elsif var = controller.instance_variable_get(ivar + 's')
+            name = ivar + 's'
+            klass = [var.first.class]
+          end
+          return Zafu::NodeContext.new(name, klass) if name
+        end
+        raise Exception.new("Could not guess main instance variable from request parameters, please add something like \"zafu_node('@var_name', Page)\" in your action.")
+      end
+  end
+end
+
+class ActionView::Template
+  attr_reader :view
+  def render_template_with_zafu(view, local_assigns = {})
+    Thread.current[:view] = view
+    render_template_without_zafu(view, local_assigns)
+  end
+  alias_method_chain :render_template, :zafu
+end

data/lib/zafu/info.rb

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

data/lib/zafu/markup.rb

@@ -0,0 +1,186 @@
+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]
+
+    # Tag used ("li" for example). The tag can be nil (no tag).
+    attr_accessor :tag
+    # Tag parameters (.. class='xxx' id='yyy')
+    attr_accessor :params
+    # Dynamic tag parameters that should not be escaped. For example: (.. class='<%= @node.klass %>')
+    attr_accessor :dyn_params
+    # Ensure wrap is not called more then once unless this attribute has been reset in between
+    attr_accessor :done
+    # Space to insert before tag
+    attr_accessor :space_before
+    # Space to insert after tag
+    attr_accessor :space_after
+
+    class << self
+
+      # 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 text if text.kind_of?(Hash)
+        params = {}
+        rest = text.strip
+        while (rest != '')
+          if rest =~ /(.+?)=/
+            key = $1.strip.to_sym
+            rest = rest[$&.length..-1].strip
+            if rest =~ /('|")(|[^\1]*?[^\\])\1/
+              rest = rest[$&.length..-1].strip
+              key_counter = 1
+              while params[key]
+                key = "#{key}#{key_counter}".to_sym
+                key_counter += 1
+              end
+
+              if $1 == "'"
+                params[key] = $2.gsub("\\'", "'")
+              else
+                params[key] = $2.gsub('\\"', '"')
+              end
+            else
+              # error, bad format, return found params.
+              break
+            end
+          else
+            # error, bad format
+            break
+          end
+        end
+        params
+      end
+    end
+
+    def initialize(tag)
+      @done       = false
+      @tag        = tag
+      @params     = {}
+      @dyn_params = {}
+    end
+
+    # Set params either using a string (like "alt='time passes' class='zen'")
+    def params=(p)
+      if p.kind_of?(Hash)
+        @params = p
+      else
+        @params = Markup.parse_params(p)
+      end
+    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|
+        next unless p[k]
+        @params[k] = p.delete(k)
+      end
+    end
+
+    # Compile dynamic parameters as ERB. A parameter is considered dynamic if it
+    # contains the string eval "#{...}"
+    def compile_params(helper)
+      @params.each do |key, value|
+        if value =~ /^(.*)\#\{(.*)\}(.*)$/
+          @params.delete(key)
+          if $1 == '' && $3 == ''
+            append_dyn_param(key, "<%= #{RubyLess.translate($2, helper)} %>")
+          else
+            append_dyn_param(key, "<%= #{RubyLess.translate_string(value, helper)} %>")
+          end
+        end
+      end
+    end
+
+    # Set dynamic html parameters.
+    def set_dyn_params(hash)
+      hash.keys.each do |k|
+        @params.delete(k)
+      end
+      @dyn_params.merge!(hash)
+    end
+
+    # Set static html parameters.
+    def set_params(hash)
+      hash.keys.each do |k|
+        @dyn_params.delete(k)
+      end
+      @params.merge!(hash)
+    end
+
+    def append_param(key, value)
+      if prev_value = @dyn_params[key]
+        @dyn_params[key] = "#{prev_value} #{value}"
+      elsif prev_value = @params[key]
+        @params[key] = "#{prev_value} #{value}"
+      else
+        @params[key] = value
+      end
+    end
+
+    def append_dyn_param(key, value)
+      if prev_value = @params.delete(key)
+        @dyn_params[key] = "#{prev_value} #{value}"
+      elsif prev_value = @dyn_params[key]
+        @dyn_params[key] = "#{prev_value} #{value}"
+      else
+        @dyn_params[key] = value
+      end
+    end
+
+    # Define the DOM id from a node context
+    def set_id(erb_id)
+      params[:id] = nil
+      dyn_params[:id] = erb_id
+    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
+      append ||= []
+      if @tag
+        if text.blank? && EMPTY_TAGS.include?(@tag)
+          res = "<#{@tag}#{params_to_html}#{append.join('')}/>"
+        else
+          res = "<#{@tag}#{params_to_html}#{append.join('')}>#{text}</#{@tag}>"
+        end
+      else
+        res = text
+      end
+      @done = true
+
+      (@space_before || '') + res + (@space_after || '')
+    end
+
+    private
+      def params_to_html
+        para = []
+        keys = []
+
+        @dyn_params.each do |k,v|
+          keys << k
+          para << " #{k}='#{v}'"
+        end
+
+        @params.each do |k,v|
+          next if keys.include?(k)
+
+          if !v.to_s.include?("'")
+            para << " #{k}='#{v}'"
+          else
+            para << " #{k}=\"#{v.to_s.gsub('"','\"')}\"" # TODO: do this work in all cases ?
+          end
+        end
+
+        # we sort so that the output is always the same (needed for testing)
+        para.sort.join('')
+      end
+  end
+end

data/lib/zafu/mock_helper.rb

@@ -0,0 +1,42 @@
+module Zafu
+  # This is the 'src_helper' used when none is provided. Its main purpose is to provide some information
+  # during testing.
+  class MockHelper
+    def initialize(strings = {})
+      @strings = strings
+    end
+
+    def get_template_text(opts)
+      src    = opts[:src]
+      folder = (opts[:base_path] && opts[:base_path] != '') ? opts[:base_path][1..-1].split('/') : []
+      src = src[1..-1] if src[0..0] == '/' # just ignore the 'relative' or 'absolute' tricks.
+      url = (folder + src.split('/')).join('_')
+      if test = @strings[url]
+        return [test['src'], url.split('_').join('/')]
+      else
+        nil
+      end
+    end
+
+    def template_url_for_asset(opts)
+      "/test_#{opts[:type]}/#{opts[:src]}"
+    end
+
+    def method_missing(sym, *args)
+      arguments = args.map do |arg|
+        if arg.kind_of?(Hash)
+          res = []
+          arg.each do |k,v|
+            unless v.nil?
+              res << "#{k}:#{v.inspect.gsub(/'|"/, "|")}"
+            end
+          end
+          res.sort.join(' ')
+        else
+          arg.inspect.gsub(/'|"/, "|")
+        end
+      end
+      res = "[#{sym} #{arguments.join(' ')}]"
+    end
+  end # DummyHelper
+end

data/lib/zafu/node_context.rb

@@ -0,0 +1,96 @@
+module Zafu
+  class NodeContext
+    # The name of the variable halding the current object or list ("@node", "var1")
+    attr_reader :name
+
+    # The type of object contained in the current context (Node, Page, Image)
+    attr_reader :klass
+
+    # The current DOM prefix to use when building DOM ids. This is set by the parser when
+    # it has a name or dom id defined ('main', 'related', 'list', etc).
+    attr_writer :dom_prefix
+
+    def initialize(name, klass, up = nil)
+      @name, @klass, @up = name, klass, up
+    end
+
+    def move_to(name, klass)
+      NodeContext.new(name, klass, self)
+    end
+
+    # Since the idiom to write the node context name is the main purpose of this class, it
+    # deserves this shortcut.
+    def to_s
+      name
+    end
+
+    # 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)
+    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
+      NodeContext.new("@#{klass.to_s.underscore}", klass)
+    end
+
+    # Generate a unique DOM id for this element based on dom_scopes defined in parent contexts.
+    def dom_id
+      @dom_id ||= begin
+        if @up
+          [dom_prefix] + @up.dom_scopes + [make_scope_id]
+        else
+          [dom_prefix] + [make_scope_id]
+        end.compact.uniq.join('_')
+      end
+    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 ?
+    def dom_prefix
+      @dom_prefix || (@up ? @up.dom_prefix : nil)
+    end
+
+    # Mark the current context as being a looping element (each) whose DOM id needs to be propagated to sub-nodes
+    # in order to ensure uniqueness of the dom_id (loops in loops problem).
+    def dom_scope!
+      @dom_scope = true
+    end
+
+    def get(klass)
+      if list_context?
+        if self.klass.first.ancestors.include?(klass)
+          NodeContext.new("#{self.name}.first", self.klass.first)
+        elsif @up
+          @up.get(klass)
+        else
+          nil
+        end
+      elsif self.klass.ancestors.include?(klass)
+        return self
+      elsif @up
+        @up.get(klass)
+      else
+        nil
+      end
+    end
+
+    def list_context?
+      klass.kind_of?(Array)
+    end
+
+    protected
+      # List of scopes defined in ancestry (used to generate dom_id).
+      def dom_scopes
+        (@up ? @up.dom_scopes : []) + (@dom_scope ? [make_scope_id] : [])
+      end
+
+    private
+      def make_scope_id
+        "<%= #{@name}.zip %>"
+      end
+  end
+end