zafu 0.5.0

data/lib/zafu/process/ruby_less.rb

@@ -0,0 +1,145 @@
+require 'rubyless'
+
+module Zafu
+  module Process
+    module RubyLess
+      include ::RubyLess::SafeClass
+      # Actual method resolution. The lookup first starts in the current helper. If nothing is found there, it
+      # searches inside a 'helpers' module and finally looks into the current node_context.
+      # If nothing is found at this stage, we prepend the method with the current node and start over again.
+      def safe_method_type(signature)
+        get_method_type(signature, false)
+      end
+
+      # Resolve unknown methods by using RubyLess in the current compilation context (the
+      # translate method in RubyLess will call 'safe_method_type' in this module).
+      def r_unknown
+        rubyless_render(@method, @params)
+      rescue ::RubyLess::NoMethodError => err
+        parser_error("#{err.error_message} <span class='type'>#{err.method_with_arguments}</span>", err.receiver_with_class)
+      rescue ::RubyLess::Error => err
+        parser_error(err.message)
+      end
+
+      # Print documentation on the current node type.
+      def r_m
+        if @params[:helper] == 'true'
+          klass = helper.class
+        else
+          klass = node.klass
+        end
+
+        out "<div class='rubyless-m'><h3>Documentation for <b>#{klass}</b></h3>"
+        out "<ul>"
+        ::RubyLess::SafeClass.safe_methods_for(klass).each do |signature, opts|
+          opts = opts.dup
+          opts.delete(:method)
+          if opts.keys == [:class]
+            opts = opts[:class]
+          end
+          out "<li>#{signature.inspect} => #{opts.inspect}</li>"
+        end
+        out "</ul></div>"
+      end
+
+      # TEMPORARY METHOD DURING HACKING...
+      def r_erb
+        "<pre><%= @erb.gsub('<','&lt;').gsub('>','&gt;') %></pre>"
+      end
+
+      def rubyless_render(method, params)
+        rubyless_expand(::RubyLess.translate(method_with_arguments(method, params), self))
+      end
+
+      def rubyless_attr(val)
+        ::RubyLess.translate_string(val, self)
+      end
+
+      private
+        def get_method_type(signature, added_options = false)
+          if type = node_context_from_signature(signature)
+            # Resolve @page, @node
+            type
+          elsif type = safe_method_from(helper, signature)
+            # Resolve template helper methods
+            type
+          elsif helper.respond_to?(:helpers) && type = safe_method_from(helper.helpers, signature)
+            # Resolve by looking at the included helpers
+            type
+          elsif node && node.klass.kind_of?(Class) && type = safe_method_from(node.klass, signature)
+            # Resolve node context methods (xxx.foo, xxx.bar)
+            type.merge(:method => "#{node.name}.#{type[:method]}")
+          elsif node && !added_options
+            # Try prepending current node before arguments: link("foo") becomse link(var1, "foo")
+            signature_with_node = signature.dup
+            signature_with_node.insert(1, node.klass)
+            if type = get_method_type(signature_with_node, added_options = true)
+              type = type.merge(:prepend_args => ::RubyLess::TypedString.new(node.name, :class => node.klass))
+              type
+            else
+              nil
+            end
+          else
+            nil
+          end
+        end
+
+        def method_with_arguments(method, params)
+          hash_arguments = {}
+          arguments = []
+          keys = params.keys.map {|k| k.to_s}
+          keys.sort.each do |k|
+            if k.to_s =~ /\A_/
+              arguments << params[k.to_sym]
+            else
+              hash_arguments[k.to_s] = params[k.to_sym]
+            end
+          end
+
+          arguments += [hash_arguments] if hash_arguments != {}
+          if arguments != [] && method[-1..-1] =~ /\w/
+            "#{method}(#{arguments.inspect[1..-2]})"
+          else
+            method
+          end
+        end
+
+        def rubyless_expand(res)
+          if res.klass == String && @blocks.map {|b| b.kind_of?(String) ? nil : b.method}.compact.empty?
+            out "<%= #{res} %>"
+          elsif res.could_be_nil?
+            out "<% if #{var} = #{res} -%>"
+            out @markup.wrap(expand_with_node(var, res.klass))
+            out "<% end -%>"
+          else
+            out "<% #{var} = #{res} -%>"
+            out @markup.wrap(expand_with_node(var, res.klass))
+          end
+        end
+
+        # This is used to resolve '@node' as NodeContext with class Node, '@page' as first NodeContext
+        # of type Page, etc.
+        def node_context_from_signature(signature)
+          return nil unless signature.size == 1
+          ivar = signature.first
+          return nil unless ivar[0..0] == '@'
+          begin
+            klass = Module.const_get(ivar[1..-1].capitalize)
+            context = node(klass)
+          rescue NameError
+            return nil
+          end
+          {:class => context.klass, :method => context.name}
+        end
+
+        def safe_method_from(context, signature)
+          if context.respond_to?(:safe_method_type)
+            context.safe_method_type(signature)
+          else
+            ::RubyLess::SafeClass.safe_method_type_for(context, signature)
+          end
+        end
+
+    end # RubyLess
+  end # Process
+end # Zafu

data/lib/zafu/template.rb

@@ -0,0 +1,25 @@
+require 'zafu/compiler'
+
+module Zafu
+  class Template
+    def initialize(template, src_helper = nil, compiler = Zafu::Compiler)
+      if template.kind_of?(String)
+        @ast = compiler.new(template)
+      else
+        @ast = compiler.new_with_url(template.path, :helper => src_helper)
+      end
+    end
+
+    def to_erb(context = {})
+      @ast.to_erb(context)
+    end
+
+    def to_ruby(context = {})
+      src = ::ERB.new("<% __in_erb_template=true %>#{to_erb(context)}", nil, '-').src
+
+      # Ruby 1.9 prepends an encoding to the source. However this is
+      # useless because you can only set an encoding on the first line
+      RUBY_VERSION >= '1.9' ? src.sub(/\A#coding:.*\n/, '') : src
+    end
+  end
+end

data/lib/zafu/test_helper.rb

@@ -0,0 +1,19 @@
+require 'zafu/template'
+
+module Zafu
+  module TestHelper
+    include ::RubyLess::SafeClass
+
+    def zafu_erb(source, src_helper = self, compiler = Zafu::Compiler)
+      Zafu::Template.new(source, src_helper, compiler).to_erb(compilation_context)
+    end
+
+    def zafu_render(source, src_helper = self, compiler = Zafu::Compiler)
+      eval Zafu::Template.new(source, src_helper, compiler).to_ruby(compilation_context)
+    end
+
+    def compilation_context
+      {:node => @node_context, :helper => self}
+    end
+  end
+end

data/lib/zafu.rb

@@ -0,0 +1,7 @@
+require 'zafu/all'
+
+if defined?(ActionView)
+  require 'zafu/handler'
+  ActionView::Template.register_template_handler(:zafu, Zafu::Handler)
+  ActionView::Template.register_template_handler(:html, Zafu::Handler)
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'zafu' #File.join(File.dirname(__FILE__), '..', 'lib', 'zafu')

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/zafu.rb'}"
+puts "Loading zafu gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/markup_test.rb

@@ -0,0 +1,232 @@
+require 'test_helper'
+
+class String
+  def blank?
+    self == ''
+  end
+end
+
+class NodeContextTest < Test::Unit::TestCase
+  include RubyLess::SafeClass
+  safe_method :day => {:class => String, :method => %q{Time.now.strftime('%A')}}
+  Markup = Zafu::Markup
+
+  context 'Parsing parameters' do
+    should 'retrieve values escaped with single quotes' do
+      h = {:class => 'worker', :style => 'tired'}
+      assert_equal h, Markup.parse_params("class='worker' style='tired'")
+    end
+
+    should 'retrieve values escaped with double quotes' do
+      h = {:class => 'worker', :style => 'tired'}
+      assert_equal h, Markup.parse_params('class="worker" style="tired"')
+    end
+
+    should 'retrieve values escaped with mixed quotes' do
+      h = {:class => 'worker', :style => 'tired'}
+      assert_equal h, Markup.parse_params('class=\'worker\' style="tired"')
+    end
+
+    should 'properly handle escaped single quotes' do
+      h = {:class => "that's nice", :style => 'tired'}
+      assert_equal h, Markup.parse_params("class='that\\\'s nice' style='tired'")
+    end
+
+    should 'properly handle escaped double quotes' do
+      h = {:class => '30"', :style => 'tired'}
+      assert_equal h, Markup.parse_params('class="30\\"" style="tired"')
+    end
+  end
+
+  context 'Setting parameters' do
+    setup do
+      @markup = Markup.new('p')
+    end
+
+    should 'parse params if the parameters are provided as a string' do
+      @markup.params = "class='shiny' id='slogan'"
+      h = {:class => 'shiny', :id => 'slogan'}
+      assert_equal h, @markup.params
+    end
+
+    should 'set params if the parameters are provided as a hash' do
+      @markup.params = {:class => 'shiny', :style => 'good'}
+      h = {:class => 'shiny', :style => 'good'}
+      assert_equal h, @markup.params
+    end
+  end
+
+  context 'Stealing html params' do
+    setup do
+      @markup = Markup.new('p')
+    end
+
+    should 'remove common html params' do
+      base = {:class => 'blue', :name => 'sprout', :id => 'front_cover', :style => 'padding:5px;', :attr => 'title'}
+      @markup.steal_html_params_from(base)
+      new_base = {:name => 'sprout', :attr => 'title'}
+      markup_params = {:class => 'blue', :id => 'front_cover', :style => 'padding:5px;'}
+      assert_equal new_base, base
+      assert_equal markup_params, @markup.params
+    end
+  end
+
+  context 'Defining the dom id' do
+    setup do
+      @markup = Markup.new('p')
+      @markup.params[:id] = 'foobar'
+      @markup.dyn_params[:id] = 'foobar'
+      @markup.set_id('<%= @node.zip %>')
+    end
+
+    should 'remove any predifined id' do
+      assert_nil @markup.params[:id]
+    end
+
+    should 'write id in the dynamic params' do
+      assert_equal '<%= @node.zip %>', @markup.dyn_params[:id]
+    end
+  end
+
+  context 'Setting a dynamic param' do
+    setup do
+      @markup = Markup.new('p')
+      @markup.params[:foo] = 'one'
+      @markup.set_dyn_params(:foo => '<%= @node.two %>')
+    end
+
+    should 'clear a static param with same key' do
+      assert_nil @markup.params[:foo]
+      assert_equal '<%= @node.two %>', @markup.dyn_params[:foo]
+    end
+  end
+
+  context 'Setting a static param' do
+    setup do
+      @markup = Markup.new('p')
+      @markup.dyn_params[:foo] = '<%= @node.two %>'
+      @markup.set_params(:foo => 'one')
+    end
+
+    should 'clear a dynamic param with same key' do
+      assert_nil @markup.dyn_params[:foo]
+      assert_equal 'one', @markup.params[:foo]
+    end
+  end
+
+
+  context 'Appending a static param' do
+    context 'on a static param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_params(:class => 'simple')
+      end
+
+      should 'append param in the static params' do
+        @markup.append_param(:class, 'mind')
+        assert_equal 'simple mind', @markup.params[:class]
+      end
+    end
+
+    context 'on a dynamic param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_dyn_params(:class => '<%= @foo %>')
+      end
+
+      should 'append param in the dynamic params' do
+        @markup.append_param(:class, 'bar')
+        assert_equal '<%= @foo %> bar', @markup.dyn_params[:class]
+      end
+    end
+
+    context 'on an empty param' do
+      setup do
+        @markup = Markup.new('p')
+      end
+
+      should 'set param in the static params' do
+        @markup.append_param(:class, 'bar')
+        assert_equal 'bar', @markup.params[:class]
+      end
+    end
+  end
+
+  context 'Appending a dynamic param' do
+    context 'on a static param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_params(:class => 'simple')
+      end
+
+      should 'copy the static param in the dynamic params' do
+        @markup.append_dyn_param(:class, '<%= @mind %>')
+        assert_equal 'simple <%= @mind %>', @markup.dyn_params[:class]
+      end
+    end
+
+    context 'on a dynamic param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_dyn_params(:class => '<%= @foo %>')
+      end
+
+      should 'append param in the dynamic params' do
+        @markup.append_dyn_param(:class, '<%= @bar %>')
+        assert_equal '<%= @foo %> <%= @bar %>', @markup.dyn_params[:class]
+      end
+    end
+
+    context 'on an empty param' do
+      setup do
+        @markup = Markup.new('p')
+      end
+
+      should 'set param in the dynamic params' do
+        @markup.append_dyn_param(:class, '<%= @bar %>')
+        assert_equal '<%= @bar %>', @markup.dyn_params[:class]
+      end
+    end
+  end
+
+  context 'Wrapping some text' do
+    setup do
+      @text = 'Alice: It would be so nice if something made sense for a change.'
+      @markup = Markup.new('p')
+      @markup.params = {:class => 'quote', :style => 'padding:3px; border:1px solid red;'}
+    end
+
+    should 'add the markup tag around the text' do
+      assert_equal "<p class='quote' style='padding:3px; border:1px solid red;'>#{@text}</p>", @markup.wrap(@text)
+    end
+
+    should 'not wrap twice if called twice' do
+      assert_equal "<p class='quote' style='padding:3px; border:1px solid red;'>#{@text}</p>", @markup.wrap(@markup.wrap(@text))
+    end
+  end
+
+  context 'Compiling params' do
+    setup do
+      @markup = Markup.new('p')
+      @markup.params = %q{class='one #{day}' id='foobar' name='#{day}'}
+    end
+
+    context 'with compile_params' do
+      setup do
+        @markup.compile_params(self)
+      end
+
+      should 'translate dynamic params into ERB by using RubyLess' do
+        assert_equal %q{<%= "one #{Time.now.strftime('%A')}" %>}, @markup.dyn_params[:class]
+      end
+
+      should 'translate without string on single dynamic content' do
+        assert_equal %q{<%= Time.now.strftime('%A') %>}, @markup.dyn_params[:name]
+      end
+    end
+  end
+end
+
+
+
+

data/test/mock/params.rb

@@ -0,0 +1,19 @@
+module Mock
+  module Params
+    def self.included(base)
+      base.before_process :filter_params
+    end
+
+    def filter_params
+      if klass = @params.delete(:class)
+        if klass =~ /#\{/
+          res = RubyLess.translate("\"#{klass}\"", self)
+          @markup.append_dyn_param(:class, "<%= #{res} %>")
+        else
+          @markup.append_param(:class, klass)
+        end
+      end
+      true
+    end
+  end
+end

data/test/node_context_test.rb

@@ -0,0 +1,190 @@
+require 'test_helper'
+
+class NodeContextTest < Test::Unit::TestCase
+  class Page;end
+  class SubPage < Page; end
+  class Comment;end
+  NodeContext = Zafu::NodeContext
+
+  context 'In a blank context' do
+    setup do
+      @context = NodeContext.new('@node', Page)
+    end
+
+    should 'return the current name' do
+      assert_equal '@node', @context.name
+    end
+
+    should 'return the current class' do
+      assert_equal Page, @context.klass
+    end
+    
+    should 'return true on will_be with the same class' do
+      assert @context.will_be?(Page)
+    end
+    
+    should 'return false on will_be with a sub class' do
+      assert !@context.will_be?(SubPage)
+    end
+    
+    should 'return false on will_be with a different class' do
+      assert !@context.will_be?(String)
+    end
+
+    should 'return self on a get for the same class' do
+      assert_equal @context.object_id, @context.get(Page).object_id
+    end
+
+    should 'return nil on a get for another class' do
+      assert_nil @context.get(Comment)
+    end
+    
+    context 'with a sub-class' do
+      setup do
+        @context = NodeContext.new('@node', SubPage)
+      end
+      
+      should 'return true on will_be with the same class' do
+        assert @context.will_be?(SubPage)
+      end
+
+      should 'return true on will_be with a super class' do
+        assert @context.will_be?(Page)
+      end
+
+      should 'return false on will_be with a different class' do
+        assert !@context.will_be?(String)
+      end
+    end
+  end
+
+  context 'In a sub-context' do
+    setup do
+      @parent  = NodeContext.new('@node', Page)
+      @context = @parent.move_to('comment1', Comment)
+    end
+
+    should 'return the current name' do
+      assert_equal 'comment1', @context.name
+    end
+
+    should 'return the current class' do
+      assert_equal Comment, @context.klass
+    end
+
+    should 'return self on a get for the same class' do
+      assert_equal @context.object_id, @context.get(Comment).object_id
+    end
+
+    should 'return the parent on a get for the class of the parent' do
+      assert_equal @parent.object_id, @context.get(Page).object_id
+    end
+  end
+
+  context 'In a deeply nested context' do
+    setup do
+      @grandgrandma = NodeContext.new('@comment', Comment)
+      @grandma = @grandgrandma.move_to('page', Page)
+      @mother  = @grandma.move_to('comment1', Comment)
+      @context = @mother.move_to('var1', String)
+    end
+
+    should 'return the current name' do
+      assert_equal 'var1', @context.name
+    end
+
+    should 'return the current class' do
+      assert_equal String, @context.klass
+    end
+
+    should 'return the first ancestor matching class on get' do
+      assert_equal @mother.object_id, @context.get(Comment).object_id
+    end
+
+    should 'return nil if no ancestor matches class on get' do
+      assert_nil @context.get(Fixnum)
+    end
+  end
+
+  context 'In a sub-classes context' do
+    setup do
+      @context = NodeContext.new('super', SubPage)
+    end
+
+    should 'find the current context required class is an ancestor' do
+      assert_equal @context.object_id, @context.get(Page).object_id
+    end
+  end
+
+  context 'In a list context' do
+    setup do
+      @context = NodeContext.new('list', [Page])
+    end
+
+    should 'find the context and resolve with first' do
+      assert context = @context.get(Page)
+      assert_equal 'list.first', context.name
+      assert_equal Page, context.klass
+    end
+  end
+
+  context 'Generating a dom id' do
+    context 'in a blank context' do
+      setup do
+        @context = NodeContext.new('@foo', Page)
+      end
+
+      should 'return the node name in DOM id' do
+        assert_equal '<%= @foo.zip %>', @context.dom_id
+      end
+    end
+
+    context 'in a hierarchy of contexts' do
+      setup do
+        @a       = NodeContext.new('@node', Page)
+        @b       = NodeContext.new('var1', [Page], @a)
+        @c       = NodeContext.new('var2', Page, @b)
+        @context = NodeContext.new('var3', Page, @c)
+      end
+
+      context 'with parents as dom_scopes' do
+        setup do
+          @b.dom_scope!
+          @c.dom_scope!
+        end
+
+        should 'use dom_scopes' do
+          assert_equal '<%= var1.zip %>_<%= var2.zip %>_<%= var3.zip %>', @context.dom_id
+        end
+      end
+
+      context 'with ancestors and self as dom_scopes' do
+        setup do
+          @a.dom_scope!
+          @context.dom_scope!
+        end
+
+        should 'not use self twice' do
+          assert_equal '<%= @node.zip %>_<%= var3.zip %>', @context.dom_id
+        end
+      end
+
+      context 'with a parent defining a dom_prefix' do
+        setup do
+          @b.dom_prefix = 'cart'
+        end
+
+        should 'use dom_prefix' do
+          assert_equal 'cart_<%= var3.zip %>', @context.dom_id
+        end
+      end
+
+    end
+  end
+end
+
+
+
+
+
+