ramaze 0.0.7 → 0.0.8

data/lib/ramaze/template/ezamar/engine.rb

@@ -0,0 +1,124 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'digest/sha1'
+
+# Ezamar is a very simple (and at no means complete) reimplementation of the
+# Templating-engine found in Nitro.
+#
+# Since Nitros templating is based on REXML and Ezamar is not there are vast
+# differences, but it tries to keep the look and feel as close as possible.
+
+module Ezamar
+
+  require 'ramaze/template/ezamar/element'
+  require 'ramaze/template/ezamar/morpher'
+
+  # This class is responsible for initializing and compiling the template.
+
+  class Template
+    attr_accessor :last_result, :file
+    attr_reader :original
+
+    # Start a new template with some string for your template
+    # that's going to be transformed.
+
+    def initialize source, options = {}
+      @original = @source = source
+      @binding, @file = options.values_at(:binding, :path)
+      @start_heredoc = "T" << Digest::SHA1.hexdigest(@source)
+      @start_heredoc, @end_heredoc = "\n<<#{@start_heredoc}\n", "\n#{@start_heredoc}\n"
+      @bufadd = "_out_ << "
+      @old = true
+      compile
+    end
+
+    # reset the original template you gave
+
+    def original=(original)
+      compile
+    end
+
+    # is the template old?
+
+    def old?
+      !!@old
+    end
+
+    # make the template old - mark it for recompilation.
+
+    def touch
+      @old = true
+    end
+
+    # transform a String to a final xhtml
+    #
+    # You can pass it a binding, for example from your controller.
+    #
+    # Example:
+    #
+    #   class Controller
+    #     def hello
+    #       @hello = 'Hello, World!'
+    #     end
+    #   end
+    #
+    #   controller = Controller.new
+    #   controller.hello
+    #   binding = controller.send(:binding)
+    #
+    #   Ezamar.new('#{@hello}').transform(binding)
+
+    def transform(_binding_ = @binding)
+      @compiled = compile if old?
+
+      args = @file ? [@file] : []
+
+      @last_result = eval(@compiled, _binding_, *args)
+
+      @last_result.map! do |line|
+        line.to_s.chomp
+      end
+
+      @last_result = @last_result.join.strip
+    end
+
+    # The actual compilation of the @source
+    #
+    # All ye who seek magic, look elsewhere, this method is ASAP (as simple as possible)
+    #
+    # There are some simple gsubs that build a final template which is evaluated
+    #
+    # The rules are following:
+    # <?r rubycode ?>
+    #   evaluate the code inside the tag, this is considered XHTML-valid and so is the
+    #   preferred method for executing code inside your templates.
+    #   The return-value is ignored
+    # <% rubycode %>
+    #   The same as <?r ?>, ERB-style and not valid XHTML, but should give someone who
+    #   is already familiar with ERB some common ground
+    # #{ rubycode }
+    #   You know this from normal ruby already and it's actually nothing else.
+    #   Interpolation at the position in the template, isn't any special taggy format
+    #   and therefor safe to use.
+    # <%= rubycode %>
+    #   The result of this will be interpolated at the position in the template.
+    #   Not valid XHTML either.
+    #
+    # The result of the compilation will be stored in @compiled.
+
+    def compile
+      @source.gsub!(/<%\s+(.*?)\s+%>/m,
+          "#{@end_heredoc} \\1; #{@bufadd} #{@start_heredoc}")
+      @source.gsub!(/<\?r\s+(.*?)\s+\?>/m,
+          "#{@end_heredoc} \\1; #{@bufadd} #{@start_heredoc}")
+      @source.gsub!(/<%=\s+(.*?)\s+%>/m,
+          "#{@end_heredoc} #{@bufadd} (\\1); #{@bufadd} #{@start_heredoc}")
+
+      @source = [@bufadd, @start_heredoc, @source, @end_heredoc].join(' ')
+
+      @old = false
+      @compiled = "_out_ = []; #{@source}; _out_"
+    end
+  end
+end

data/lib/ramaze/template/ezamar/morpher.rb

@@ -0,0 +1,155 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze/template/ezamar/engine'
+
+# This applies a morphing-replace for the template.
+#
+# To use the functionality of Morpher you will need to have hpricot
+# installed, you will get one error in case you don't and the method
+# will be replaced by a stub that simply returns the template.
+#
+# The method first checks if you use any morphers and just skips
+# the step if you don't, this should give quite some speedup for
+# smaller templates that don't use this functionality at all.
+# the check works by searching the morphs with appended '='
+# in the template. There may be a few cases where this won't work
+# since we cannot make any assumptions on the format.
+#
+# If you want to turn this functionality off, either remove Morpher
+# from:
+#   Ramaze::Template::Ezamar.trait[:transform_pipeline]
+# or do:
+#   Ramaze::Morpher.trait[:morphs] = {}
+#
+# The latter is a tad slower, but i mention the possibility in case you
+# find good use for it.
+#
+# You can add your own morphers in Ramaze::Morpher.trait[:morphs]
+#
+# For Example:
+#
+#   Morpher.trait[:morphs]['if'] = '<?r %morph %expression ?>%content<?r end ?>'
+#
+# Now, assuming that some tag in your template is '<a if="@foo">x</a>'
+#
+# %morph stands for the name of your morph: 'if'
+# %expression is the stuff you write in the attribute: '@foo'
+# %content is the tag without the attribute (and all inside): '<a>x</a>'
+
+class Ezamar::Morpher
+
+  # Use this trait to define your custom morphs.
+  trait :morphs => {
+                      'if'     => '<?r %morph %expression ?>%content<?r end ?>',
+                      'unless' => '<?r %morph %expression ?>%content<?r end ?>',
+                      'for'    => '<?r %morph %expression ?>%content<?r end ?>',
+                      'each'   => '<?r %expression.%morph do |_e| ?>%content<?r end ?>',
+                      'times'  => '<?r %expression.%morph do |_t| ?>%content<?r end ?>',
+  }
+
+  # Since the functionality is best explained by examples, here they come.
+  #
+  # Example:
+  #
+  # if:
+  #   <div if="@name">#@name</div>
+  # morphs to:
+  #   <?r if @name ?>
+  #     <div>#@name</div>
+  #   <?r end ?>
+  #
+  # unless:
+  #   <div unless="@name">No Name</div>
+  # morphs to:
+  #   <?r unless @name ?>
+  #     <div>No Name</div>
+  #   <?r end ?>
+  #
+  # for:
+  #   <div for="name in @names">#{name}</div>
+  # morphs to:
+  #   <?r for name in @names ?>
+  #     <div>#{name}</div>
+  #   <?r end ?>
+  #
+  # times:
+  #   <div times="3">#{_t}<div>
+  # morphs to:
+  #   <?r 3.times do |_t| ?>
+  #     <div>#{_t}</div>
+  #   <?r end ?>
+  #
+  # each:
+  #   <div each="[1,2,3]">#{_e}</div>
+  # morphs to:
+  #   <?r [1,2,3].each do |_e| ?>
+  #     <div>#{_e}</div>
+  #   <?r end ?>
+  #
+  # The latter two examples show you also one standard introduced by a
+  # limitation of the replacement-system.
+  #
+  # When you yield a value, please name it by the first character(s) of
+  # the morphs name, with an underscore prefixed.
+  #
+  # for each an _e, for times a _t.
+  #
+  # This is by far not the best way to handle it and might lead to problems
+  # due to the lack of proper scoping in ruby (if you define an _e or _t
+  # before the block it will be overwritten).
+  #
+  # So please be careful, I tried to come up with something that is both easy
+  # to write and doesn't look outright awful while keeping an easy to remember
+  # mnemonic.
+  #
+  # TODO:
+  #   - Add pure Ruby implementation as a fall-back.
+
+  def self.transform template, options = {}
+    morphs =
+      trait[:morphs].map{|k,v| [k.to_s, v.to_s]}.select do |(k,v)|
+      template.to_s.include?("#{k}=")
+      end
+
+    morphs = Hash[*morphs.flatten]
+
+    return template if morphs.empty?
+
+    require 'hpricot'
+
+    hp = Hpricot(template)
+    hp.each_child do |child|
+      if child.elem?
+        morphs.each_pair do |morph, replacement|
+          if expression = child[morph]
+            old = child.to_html
+            child.remove_attribute(morph)
+
+            replacement = replacement.dup.
+              gsub('%morph',      morph).
+              gsub('%expression', expression).
+              gsub('%content',    child.to_html)
+
+            template.gsub!(old, replacement)
+          end
+        end
+      end
+    end
+
+    template
+
+  rescue LoadError => ex
+    error "Please install hpricot (for example via `gem install hpricot`) to get morphing"
+
+    # replace this method with a stub that only returns the template.
+
+    self.class_eval do
+      def self.transform(template, options = {})
+        template
+      end
+    end
+
+    template
+  end
+end

data/lib/ramaze/template/haml.rb

@@ -1,65 +1,38 @@
 #          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'ramaze/template/haml/actionview_stub'
 require 'haml/engine'
 
 module Ramaze::Template
   class Haml < Template
 
-    # Actions consist of both templates and methods on the controller.
-    trait :actionless => false
-
-    # Usual extensions for templates.
-    trait :template_extensions => %w[haml]
-
     # Custom HAML-options for your controller to be merged.
+
     trait :haml_options => {
-      :locals => {}
-    }
+            :locals => {}
+          }
 
-    class << self
+    Ramaze::Controller.register_engine self, %w[ haml ]
 
-      # initializes the handling of a request on the controller.
-      # Creates a new instances of itself and sends the action and params.
-      # Also tries to render the template.
-      # In Theory you can use this standalone, this has not been tested though.
+    class << self
 
-      def handle_request action, *params
-        controller = self.new
-        controller.instance_variable_set('@action', action)
-        result = controller.send(action, *params) if controller.respond_to?(action)
+      # Transform any String via Haml, takes optionally an hash with the haml_options
+      # that you can set also by
+      #   trait :haml_options => {}
+      # if you pass the options it will merge the trait with them. (your options
+      # override the defaults from trait[:haml_options]
 
-        file = find_template(action)
+      def transform controller, options = {}
+        action, parameter, file, bound = *super
 
-        template =
-          if file
-            File.read(file)
-          elsif result.respond_to? :to_str
-            result
-          end
+        reaction = controller.send(action, *parameter)
+        template = reaction_or_file(reaction, file)
 
         return '' unless template
 
-        controller.send(:transform, template)
-      rescue Object => ex
-        puts ex
-        Informer.error ex
-        ''
+        haml = ::Haml::Engine.new(template, ancestral_trait[:haml_options])
+        haml.to_html(controller)
       end
     end
-
-    private
-
-    # Transform any String via Haml, takes optionally an hash with the haml_options
-    # that you can set also by
-    #   trait :haml_options => {}
-    # if you pass the options it will merge the trait with them. (your options
-    # override the defaults from trait[:haml_options]
-
-    def transform string, options = {}
-      haml = ::Haml::Engine.new(string, ancestral_trait[:haml_options].merge(options))
-      haml.to_html(self)
-    end
   end
 end

data/lib/ramaze/template/liquid.rb

@@ -5,70 +5,30 @@ require 'liquid'
 
 module Ramaze::Template
   class Liquid < Template
-    extend Ramaze::Helper
 
-    # Actions consist of both templates and methods on the controller.
-    trait :actionless => false
-
-    # Usual extensions for templates.
-    trait :template_extensions => %w[liquid]
-
-    # Custom options for Liquid to be merged for your controller.
-    trait :liquid_options => {}
+    Ramaze::Controller.register_engine self, %w[ liquid ]
 
     class << self
+
       # initializes the handling of a request on the controller.
       # Creates a new instances of itself and sends the action and params.
       # Also tries to render the template.
       # In Theory you can use this standalone, this has not been tested though.
 
-      def handle_request action, *params
-        controller = self.new
-        controller.instance_variable_set('@action', action)
-        result = controller.send(action, *params) if controller.respond_to?(action)
-
-        file = find_template(action)
-
-        p file
+      def transform controller, options = {}
+        action, parameter, file, bound = *super
 
-        template =
-          if file
-            File.read(file)
-          elsif result.respond_to? :to_str
-            result
-          end
+        reaction = controller.send(action, *parameter)
+        template = reaction_or_file(reaction, file)
 
         return '' unless template
 
-        controller.send(:transform, template)
-      rescue Object => ex
-        puts ex
-        Informer.error ex
-        ''
-      end
-    end
-
-    private
+        hash     = controller.instance_variable_get("@hash") || {}
+        template = ::Liquid::Template.parse(template)
+        options  = controller.ancestral_trait[:liquid_options]
 
-    # Transform any String via Liquid, takes an optional hash for the parameters
-    #   transform("hi {{name}}", 'name' => 'tobi') # => "hi tobi"
-    #
-    # Usually you will just do this in the controller:
-    #
-    #   class MainController < Template::Liquid
-    #     def index
-    #       @hash = {'name' => 'tobi'}
-    #     end
-    #   end
-    #
-    # And the templating will use @hash by default, setting it to {} if it is
-    # not set yet.
-
-    def transform string, hash = {}, options = {}
-      @hash ||= hash
-      template = ::Liquid::Template.parse(string)
-      options = ancestral_trait[:liquid_options].merge(options)
-      template.render(@hash, options)
+        template.render(hash, options)
+      end
     end
   end
 end

data/lib/ramaze/template/markaby.rb

@@ -5,14 +5,53 @@ require 'markaby'
 
 module Ramaze::Template
   class Markaby < Template
-    extend Ramaze::Helper
 
-    # Actions consist of both templates and methods on the controller.
-    trait :actionless => false
+    Ramaze::Controller.register_engine self, %w[ mab ]
 
-    # Usual extensions for templates.
-    trait :template_extensions => %w[mab]
+    class << self
+      # initializes the handling of a request on the controller.
+      # Creates a new instances of itself and sends the action and params.
+      # Also tries to render the template.
+      # In Theory you can use this standalone, this has not been tested though.
+
+      def transform controller, options = {}
+        action, parameter, file, bound = *super
+
+        unless controller.private_methods.include?(action)
+          mixed_in = controller.class.ancestors === MarkabyMixin
+          controller.class.send(:include, MarkabyMixin) unless mixed_in
+
+          reaction = controller.send(action, *parameter)
+
+          mab = ::Markaby::Builder.new
+          template =
+            if file
+              transform_file(controller, file)
+            elsif reaction.respond_to? :to_str
+              reaction
+            end
+        end
+
+        return template if template
+        raise Ramaze::Error::NoAction, "No Action found for `#{action}' on #{controller.class}"
+      end
+
+      def transform_file controller, file
+        ivs = {}
+        controller.instance_variables.each do |iv|
+          ivs[iv.gsub('@', '').to_sym] = controller.instance_variable_get(iv)
+        end
+        controller.send(:mab, ivs) do
+          instance_eval(File.read(file))
+        end
+      rescue Object => ex
+        puts ex
+        raise Ramaze::Error::Template, ex.message, ex.backtrace
+      end
+    end
+  end
 
+  module MarkabyMixin
     private
 
     # use this inside your controller to directly build Markaby
@@ -27,42 +66,5 @@ module Ramaze::Template
       builder.send(:helper, :link)
       builder.new(*args, &block).to_s
     end
-
-    class << self
-
-      # Takes the action and parameter
-      # creates a new instance of itself, sets the @action instance-variable
-      # to the action just called, the sends the action and parameter further
-      # on to the instance (if the instance responds to the action)
-      #
-      # uses the #find_template method for the action to locate the template
-      # and uses the response from the template instead in case there is no
-      # template (and the response from the template responds to to_str)
-
-      def handle_request action, *params
-        controller = self.new
-        controller.instance_variable_set('@action', action)
-
-        result = controller.send(action, *params) if controller.respond_to?(action)
-        file = find_template(action)
-
-        mab = ::Markaby::Builder.new
-
-        template =
-          if file
-            ivs = {}
-            controller.instance_variables.each do |iv|
-              ivs[iv.gsub('@', '').to_sym] = controller.instance_variable_get(iv)
-            end
-            controller.send(:mab, ivs) do
-              instance_eval(File.read(file))
-            end
-          elsif result.respond_to? :to_str
-            result
-          end
-
-        template ? template : ''
-      end
-    end
   end
 end