zafu 0.5.0 → 0.6.0

data/lib/zafu/process/ruby_less_processing.rb

@@ -0,0 +1,248 @@
+require 'rubyless'
+
+module Zafu
+  module Process
+    module RubyLessProcessing
+      include RubyLess
+
+      def self.included(base)
+        base.process_unknown :rubyless_eval
+
+        base.class_eval do
+          def do_method(sym)
+            super
+          rescue RubyLess::Error => err
+            self.class.parser_error(err.message, @method)
+          end
+        end
+      end
+
+      # 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)
+        #puts [node.name, node.klass, signature].inspect
+        super || 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 rubyless_eval
+        if @method =~ /^[A-Z]\w+$/
+          return rubyless_class_scope(@method)
+        end
+
+        if code = @method[/^\#\{(.+)\}$/, 1]
+          @params[:eval] = $1
+          r_show
+        else
+          rubyless_render(@method, @params)
+        end
+      rescue RubyLess::NoMethodError => err
+        parser_error("#{err.error_message} <span class='type'>#{err.method_with_arguments}</span> (#{node.class_name} context)")
+      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)
+        # We need to set this here because we cannot pass options to RubyLess or get them back
+        # when we evaluate the method to see if we can use blocks as arguments.
+        @rendering_block_owner = true
+        code = method_with_arguments(method, params)
+        rubyless_expand RubyLess.translate(code, self)
+      ensure
+        @rendering_block_owner = false
+      end
+
+      def set_markup_attr(markup, key, value)
+        value = value.kind_of?(RubyLess::TypedString) ? value : RubyLess.translate_string(value, self)
+        if value.literal
+          markup.set_param(key, value.literal)
+        else
+          markup.set_dyn_param(key, "<%= #{value} %>")
+        end
+      end
+
+      def append_markup_attr(markup, key, value)
+        value = RubyLess.translate_string(value, self)
+        if value.literal
+          markup.append_param(key, value.literal)
+        else
+          markup.append_dyn_param(key, "<%= #{value} %>")
+        end
+      end
+
+      private
+        # block_owner should be set to true when we are resolving <r:xxx>...</r:xxx> or <div do='xxx'>...</div>
+        def get_method_type(signature, added_options = false)
+          if type = node_context_from_signature(signature)
+            # Resolve self, @page, @node
+            type
+          elsif type = get_var_from_signature(signature)
+            # Resolved stored set_xxx='something' in context.
+            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 && node.klass.kind_of?(Array) && type = safe_method_from(node.klass.first, signature)
+            type.merge(:method => "#{node.name}.first.#{type[:method]}")
+          elsif @rendering_block_owner && @blocks.first.kind_of?(String) && !added_options
+            # Insert the block content into the method: <r:trans>blah</r:trans> becomes trans("blah")
+            signature_with_block = signature.dup
+            signature_with_block << String
+            if type = get_method_type(signature_with_block, true)
+              type.merge(:prepend_args => RubyLess::TypedString.new(@blocks.first.inspect, :class => String, :literal => @blocks.first))
+            else
+              nil
+            end
+          elsif node && !added_options
+            # Try prepending current node before arguments: link("foo") becomes 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.merge(:prepend_args => RubyLess::TypedString.new(node.name, :class => node.klass))
+            else
+              nil
+            end
+          else
+            nil
+          end
+        end
+
+        def method_with_arguments(method, params)
+          hash_arguments = []
+          arguments = []
+          params.keys.sort {|a,b| a.to_s <=> b.to_s}.each do |k|
+            if k =~ /\A_/
+              arguments << "%Q{#{params[k]}}"
+            else
+              hash_arguments << ":#{k} => %Q{#{params[k]}}"
+            end
+          end
+
+          if hash_arguments != []
+            arguments << hash_arguments.join(', ')
+          end
+
+          if arguments != []
+            if method =~ /^(.*)\((.*)\)$/
+              if $2 == ''
+                "#{$1}(#{arguments.join(', ')})"
+              else
+                "#{$1}(#{$2}, #{arguments.join(', ')})"
+              end
+            else
+              "#{method}(#{arguments.join(', ')})"
+            end
+          else
+            method
+          end
+        end
+
+        def rubyless_expand(res)
+          if res.klass == String && !@blocks.detect {|b| !b.kind_of?(String)}
+            if lit = res.literal
+              out lit
+            else
+              out "<%= #{res} %>"
+            end
+          elsif @blocks.empty?
+            out "<%= #{res} %>"
+          elsif res.could_be_nil?
+            expand_with_finder(:method => res, :class => res.klass, :nil => true)
+          else
+            expand_with_finder(:method => res, :class => res.klass)
+          end
+        end
+
+        def rubyless_class_scope(class_name)
+          # capital letter ==> class conditional
+          klass = Module.const_get(class_name)
+          if klass.ancestors.include?(node.klass)
+            expand_if("#{node}.kind_of?(#{klass})")
+          else
+            # render nothing: incompatible classes
+            ''
+          end
+        rescue
+          parser_error("Invalid class name '#{class_name}'")
+        end
+
+        # Find a class or behavior based on a name. The returned class should implement
+        # 'safe_method_type'.
+        def get_class(class_name)
+          Module.const_get(class_name)
+        rescue
+          nil
+        end
+
+        # This is used to resolve 'this' (current NodeContext), '@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 {:class => node.klass, :method => node.name} if ivar == 'this'
+          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
+
+        # Find stored variables back. Stored elements are set with set_xxx='something to eval'.
+        def get_var_from_signature(signature)
+          return nil unless signature.size == 1
+          if var = get_context_var('set_var', signature.first)
+            {:method => var, :class => var.klass, :nil => var.could_be_nil?}
+          else
+            nil
+          end
+        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 # RubyLessProcessing
+  end # Process
+end # Zafu

data/lib/zafu/test_helper.rb

@@ -2,7 +2,7 @@ require 'zafu/template'
 
 module Zafu
   module TestHelper
-    include ::RubyLess::SafeClass
+    include RubyLess::SafeClass
 
     def zafu_erb(source, src_helper = self, compiler = Zafu::Compiler)
       Zafu::Template.new(source, src_helper, compiler).to_erb(compilation_context)

data/lib/zafu/view_methods.rb

@@ -0,0 +1,6 @@
+require 'zafu/controller_methods'
+module Zafu
+  module ViewMethods
+    include Zafu::ControllerMethods::Common
+  end
+end

data/test/markup_test.rb

@@ -6,8 +6,9 @@ class String
   end
 end
 
-class NodeContextTest < Test::Unit::TestCase
-  include RubyLess::SafeClass
+
+class MarkupTest < Test::Unit::TestCase
+  include RubyLess
   safe_method :day => {:class => String, :method => %q{Time.now.strftime('%A')}}
   Markup = Zafu::Markup
 
@@ -54,20 +55,43 @@ class NodeContextTest < Test::Unit::TestCase
       h = {:class => 'shiny', :style => 'good'}
       assert_equal h, @markup.params
     end
+
+    should 'respond to has_param' do
+      @markup.params     = {:class => 'one', :x => 'y'}
+      @markup.dyn_params = {:y => 'z'}
+      assert @markup.has_param?(:x)
+      assert @markup.has_param?(:y)
+      assert !@markup.has_param?(:z)
+    end
   end
 
   context 'Stealing html params' do
-    setup do
-      @markup = Markup.new('p')
+    subject do
+      Markup.new('p')
     end
 
-    should 'remove common html params' do
+    should 'transfer common html params' do
       base = {:class => 'blue', :name => 'sprout', :id => 'front_cover', :style => 'padding:5px;', :attr => 'title'}
-      @markup.steal_html_params_from(base)
+      subject.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
+      assert_equal markup_params, subject.params
+    end
+
+    context 'on a link' do
+      subject do
+        Markup.new('link')
+      end
+
+      should 'transfer common html params' do
+        base = {:rel => 'rel', :type => 'type', :class => 'blue', :name => 'sprout', :id => 'front_cover', :style => 'padding:5px;', :attr => 'title'}
+        subject.steal_html_params_from(base)
+        new_base = {:name => 'sprout', :attr => 'title'}
+        markup_params = {:type=>"type", :rel=>"rel", :id => 'front_cover', :class => 'blue', :style => 'padding:5px;'}
+        assert_equal new_base, base
+        assert_equal markup_params, subject.params
+      end
     end
   end
 
@@ -152,6 +176,43 @@ class NodeContextTest < Test::Unit::TestCase
     end
   end
 
+  context 'Prepending a static param' do
+    context 'on a static param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_params(:class => 'simple')
+      end
+
+      should 'prepend param in the static params' do
+        @markup.prepend_param(:class, 'super')
+        assert_equal 'super simple', @markup.params[:class]
+      end
+    end
+
+    context 'on a dynamic param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_dyn_params(:class => '<%= @fu %>')
+      end
+
+      should 'prepend param in the dynamic params' do
+        @markup.prepend_param(:class, 'to')
+        assert_equal 'to <%= @fu %>', @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.prepend_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
@@ -175,6 +236,11 @@ class NodeContextTest < Test::Unit::TestCase
         @markup.append_dyn_param(:class, '<%= @bar %>')
         assert_equal '<%= @foo %> <%= @bar %>', @markup.dyn_params[:class]
       end
+      
+      should 'append param without spacer if conditional' do
+        @markup.append_dyn_param(:class, '<%= @bar %>', true)
+        assert_equal '<%= @foo %><%= @bar %>', @markup.dyn_params[:class]
+      end
     end
 
     context 'on an empty param' do
@@ -189,11 +255,54 @@ class NodeContextTest < Test::Unit::TestCase
     end
   end
 
+  context 'Prepending a dynamic param' do
+    context 'on a static param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_params(:class => 'fu')
+      end
+
+      should 'copy the static param in the dynamic params' do
+        @markup.prepend_dyn_param(:class, '<%= @to %>')
+        assert_equal '<%= @to %> fu', @markup.dyn_params[:class]
+      end
+    end
+
+    context 'on a dynamic param' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.set_dyn_params(:class => '<%= @fu %>')
+      end
+
+      should 'prepend param in the dynamic params' do
+        @markup.prepend_dyn_param(:class, '<%= @to %>')
+        assert_equal '<%= @to %> <%= @fu %>', @markup.dyn_params[:class]
+      end
+      
+      should 'prepend param without spacer if conditional' do
+        @markup.prepend_dyn_param(:class, '<%= @to %>', true)
+        assert_equal '<%= @to %><%= @fu %>', @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.prepend_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;'}
+      @markup.params[:class] = 'quote'
+      @markup.params[:style] = 'padding:3px; border:1px solid red;'
     end
 
     should 'add the markup tag around the text' do
@@ -203,6 +312,12 @@ class NodeContextTest < Test::Unit::TestCase
     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
+
+    should 'display static params before dynamic and keep them ordered' do
+      @markup.set_dyn_params(:foo => '<%= @bar %>')
+      @markup.set_params(:baz => 'buzz')
+      assert_equal "<p class='quote' style='padding:3px; border:1px solid red;' baz='buzz' foo='<%= @bar %>'>foo</p>", @markup.wrap('foo')
+    end
   end
 
   context 'Compiling params' do
@@ -225,6 +340,33 @@ class NodeContextTest < Test::Unit::TestCase
       end
     end
   end
+
+  context 'Duplicating a markup' do
+    context 'and changing params' do
+      setup do
+        @markup = Markup.new('p')
+        @markup.params[:class] = 'one'
+        @duplicate = @markup.dup
+      end
+
+      should 'not propagate changes to original' do
+        @duplicate.params[:class] = 'two'
+        assert_equal "<p class='one'>one</p>", @markup.wrap('one')
+      end
+    end
+
+    context 'and wrapping' do
+      setup do
+        @markup = Markup.new('p')
+        @duplicate = @markup.dup
+      end
+
+      should 'not propagate done to duplicate' do
+        @markup.wrap('')
+        assert_equal '<p>one</p>', @duplicate.wrap('one')
+      end
+    end
+  end
 end