ramaze 0.1.0 → 0.1.1

data/lib/ramaze/template.rb

@@ -2,12 +2,12 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 # This module serves as a namespace for all templates, it will autoload
-# Amrita2, Erubis, Ezamar, Haml, Liquid and Markaby if you refer to them.
+# Amrita2, Erubis, Haml, Liquid and Markaby if you refer to them.
 
 module Ramaze
   module Template
 
-    %w[ Amrita2 Erubis Haml Liquid Markaby ].each do |const|
+    %w[ Amrita2 Erubis Haml Liquid Markaby Remarkably ].each do |const|
       autoload(const, "ramaze/template/#{const.downcase}")
     end
 
@@ -21,21 +21,30 @@ module Ramaze
 
         # pass it the results of the method of the controller
         # and a possible file, it will see if the file is an actual file
-        # and otherwise answer the contents of the response from the controller
-        # if it responds to :to_str.
-        #
-        # Answers nil if none of both is valid.
 
-        def reaction_or_file reaction, file
-          if file
+        def reaction_or_file action
+          reaction = render_method(action)
+
+          if file = action.template
             File.read(file)
-          elsif reaction.respond_to? :to_str
-            reaction
+          else
+            reaction.to_s
+          end
+        end
+
+        def result_and_file(action)
+          result = render_method(action)
+
+          if file = action.template
+            content = File.read(file)
           end
+
+          [result, content]
         end
 
-        def transform controller, options = {}
-          options.values_at(:action, :parameter, :file, :binding)
+        def render_method(action)
+          return unless method = action.method
+          action.controller.__send__(method, *action.params)
         end
       end
     end

data/lib/ramaze/template/amrita2.rb

@@ -13,20 +13,20 @@ module Ramaze::Template
 
     class << self
 
-      # Takes a controller and the options :action, :parameter, :file and :binding
+      # Takes an Action
       # The file is rendered using Amrita2::TemplateFile.
       # The Controller is used as the object for expansion.
       #
       # The parameters are set to @params in the controller before expansion.
 
-      def transform controller, options = {}
-        action, parameter, file, bound = *super
-
-        raise Ramaze::Error::Template, "No Template found for #{Request.current.request_path}" unless file
+      def transform action
+        controller, params, file =
+          action.controller, action.params, action.template
+        raise_no_action(action) unless file
 
         template = ::Amrita2::TemplateFile.new(file)
         out = ''
-        controller.instance_variable_set('@params', parameter)
+        controller.instance_variable_set('@params', params)
         template.expand(out, controller)
         out
       end

data/lib/ramaze/template/erubis.rb

@@ -18,17 +18,12 @@ module Ramaze::Template
       # Builds a template out of the method on the controller and the
       # template-file.
 
-      def transform controller, options = {}
-        action, parameter, file, bound = *super
-
-        reaction = controller.send(action, *parameter)
-        template = reaction_or_file(reaction, file)
-
-        return '' unless template
+      def transform action
+        template = reaction_or_file(action)
 
         eruby = ::Erubis::Eruby.new(template)
-        eruby.init_evaluator(:filename => file) if file
-        eruby.result(bound)
+        eruby.init_evaluator(:filename => (action.template || __FILE__))
+        eruby.result(action.binding)
       end
     end
   end

data/lib/ramaze/template/ezamar.rb

@@ -12,7 +12,10 @@ module Ramaze
 
       Ramaze::Controller.register_engine self, %w[ xhtml zmr ]
 
-      trait :transform_pipeline => [ ::Ezamar::Element, ::Ezamar::Morpher, self ]
+      trait :transform_pipeline => [
+        ::Ezamar::Element, ::Ezamar::Template
+      ]
+
       trait :actionless => true
 
       class << self
@@ -21,55 +24,10 @@ module Ramaze
         #
         # Uses Ezamar::Template to compile the template.
 
-        def transform controller, options = {}
-          if options.has_key?(:pipeline)
-            template = ::Ezamar::Template.new(controller, options)
-            template.transform(options[:binding])
-          else
-            action, parameter, file, bound = *super
-
-            real_transform controller, bound, file, action, *parameter
-          end
-        end
-
-        # The actual transformation is done here.
-        #
-        # Getting the various possible template-files and the response from
-        # the controller and then deciding based on them what goes into the
-        # #pipeline
-
-        def real_transform(controller, bound, file, action, *params)
-          file_template = file_template(file)
-          ctrl_template = render_action(controller, action, *params)
-
-          if ctrl_template.respond_to?(:exception) and not file_template
-            raise ctrl_template
-          else
-            template = file_template || ctrl_template
-            pipeline(template, :binding => bound, :path => file)
-          end
-        end
-
-        # See if a string is an actual file.
-        #
-        # Answers with the contents and otherwise nil
-
-        def file_template file
-          return File.read(file) if file
-        rescue Errno::ENOENT => ex
-          Inform.error(ex)
-        end
-
-        # Render an action, on a given controller with parameter
-
-        def render_action(controller, action, *params)
-          controller.__send__(action, *params).to_s unless action.empty?
-        rescue => ex
-          ex
-        end
-
-        def raise_no_action(controller, action)
-          raise Ramaze::Error::NoAction, "No Action found for `#{action}' on #{controller.class}"
+        def transform action
+          template = reaction_or_file(action)
+          file = (action.template || __FILE__)
+          pipeline(template.to_s, action.binding, file)
         end
 
         # go through the pipeline and call #transform on every object found there,
@@ -81,14 +39,12 @@ module Ramaze
         # TODO
         #   - put the pipeline into the Controller for use with all templates.
 
-        def pipeline(template, options = {})
-          transform_pipeline = ancestral_trait[:transform_pipeline]
-          opts = options.reject{|k,v| [:template, :path, :binding].all?{|o| k != o}}
-          opts[:pipeline] = :true
-
-          transform_pipeline.inject(template) do |memo, current|
-            current.transform(memo, opts)
+        def pipeline(template, binding, file)
+          class_trait[:transform_pipeline].each do |klass|
+            template = klass.transform(template, binding, file)
           end
+
+          template
         end
       end
     end

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

@@ -83,23 +83,21 @@ class Ezamar::Element
     # a binding to be compatible to the transform-pipeline, won't have
     # any use for it though.
 
-    def transform string = '', options = {}
-      binding, path = options.values_at(:binding, :path)
-      string = string.to_s
-      matches = string.scan(/<([A-Z][a-zA-Z0-9]*)(.*?)?>/)
+    def transform template, binding, file = __FILE__
+      matches = template.scan(/<([A-Z][a-zA-Z0-9]*)(.*?)?>/)
 
       matches.each do |(klass, params)|
         transformer = (params[-1,1] == '/' ? :without : :with)
-      string = send("transform_#{transformer}_content", string, klass)
+        template = send("transform_#{transformer}_content", template, klass)
       end
-      string
+      template
     end
 
     # transforms elements like:
     #   <Page> some content </Page>
 
-    def transform_with_content(string, klass)
-      string.gsub(/<#{klass}( .*?)?>(.*?)<\/#{klass}>/m) do |m|
+    def transform_with_content(template, klass)
+      template.gsub(/<#{klass}( .*?)?>(.*?)<\/#{klass}>/m) do |m|
         params, content = $1.to_s, $2.to_s
         finish_transform(klass, params, content)
       end
@@ -108,8 +106,8 @@ class Ezamar::Element
     # transforms elements like:
     #   <Page />
 
-    def transform_without_content(string, klass)
-      string.gsub(/<#{klass}( .*?)?\/>/) do |m|
+    def transform_without_content(template, klass)
+      template.gsub(/<#{klass}( .*?)?\/>/) do |m|
         params = $1.to_s
         finish_transform(klass, params, content = '')
       end
@@ -148,8 +146,8 @@ class Ezamar::Element
     #
     # Just remember, walk like a duck, talk like a duck.
 
-    def demunge_passed_variables(string)
-      string.scan(/\s?(.*?)="(.*?)"/).inject({}) do |hash, (key, value)|
+    def demunge_passed_variables(template)
+      template.scan(/\s?(.*?)="(.*?)"/).inject({}) do |hash, (key, value)|
         value =
         case value
         when 'true'

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

@@ -17,108 +17,47 @@ module Ezamar
   # 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
+    class << self
+
+      # 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.
+      #
+      # TODO
+      #   - provide C version or maybe use erbuis
+
+      def transform(template, binding, file = __FILE__)
+        start_heredoc = "T" << Digest::SHA1.hexdigest(template)
+        start_heredoc, end_heredoc = "\n<<#{start_heredoc}\n", "\n#{start_heredoc}\n"
+        bufadd = "_out_ << "
+
+        template.gsub!(/<%\s+(.*?)\s+%>/m,
+            "#{end_heredoc} \\1; #{bufadd} #{start_heredoc}")
+        template.gsub!(/<\?r\s+(.*?)\s+\?>/m,
+            "#{end_heredoc} \\1; #{bufadd} #{start_heredoc}")
+        template.gsub!(/<%=\s+(.*?)\s+%>/m,
+            "#{end_heredoc} #{bufadd} (\\1); #{bufadd} #{start_heredoc}")
+
+        template = "_out_ = ''; #{bufadd} #{start_heredoc} #{template} #{end_heredoc}; _out_"
+
+        eval(template, binding, file).strip
       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

@@ -106,10 +106,10 @@ class Ezamar::Morpher
   # TODO:
   #   - Add pure Ruby implementation as a fall-back.
 
-  def self.transform template, options = {}
+  def self.transform template, action, file = __FILE__
     morphs =
       trait[:morphs].map{|k,v| [k.to_s, v.to_s]}.select do |(k,v)|
-      template.to_s.include?("#{k}=")
+        template.to_s.include?("#{k}=")
       end
 
     morphs = Hash[*morphs.flatten]
@@ -145,7 +145,7 @@ class Ezamar::Morpher
     # replace this method with a stub that only returns the template.
 
     self.class_eval do
-      def self.transform(template, options = {})
+      def self.transform(template, action)
         template
       end
     end

data/lib/ramaze/template/haml.rb

@@ -22,16 +22,13 @@ module Ramaze::Template
       # if you pass the options it will merge the trait with them. (your options
       # override the defaults from trait[:haml_options]
 
-      def transform controller, options = {}
-        action, parameter, file, bound = *super
-
-        reaction = controller.send(action, *parameter)
-        template = reaction_or_file(reaction, file)
+      def transform action
+        template = reaction_or_file(action)
 
         return '' unless template
 
         haml = ::Haml::Engine.new(template, ancestral_trait[:haml_options])
-        haml.to_html(controller)
+        haml.to_html(action.controller)
       end
     end
   end

data/lib/ramaze/template/liquid.rb

@@ -15,17 +15,12 @@ module Ramaze
         # 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
+        def transform action
+          template = reaction_or_file(action)
 
-          reaction = controller.send(action, *parameter)
-          template = reaction_or_file(reaction, file)
-
-          return '' unless template
-
-          hash     = controller.instance_variable_get("@hash") || {}
+          hash     = action.controller.instance_variable_get("@hash") || {}
           template = ::Liquid::Template.parse(template)
-          options  = controller.ancestral_trait[:liquid_options]
+          options  = action.controller.ancestral_trait[:liquid_options]
 
           template.render(hash, options)
         end