ramaze 0.0.7 → 0.0.8

data/lib/ramaze/template.rb

@@ -1,102 +1,43 @@
 #          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/helper'
+# This module serves as a namespace for all templates, it will autoload
+# Amrita2, Erubis, Ezamar, Haml, Liquid and Markaby if you refer to them.
 
-module Ramaze::Template
-  %w[ Amrita2 Erubis Haml Liquid Markaby Ramaze ].each do |const|
-    autoload(const, "ramaze/template/#{const.downcase}")
-  end
-
-  class Template
-    extend ::Ramaze::Helper
-
-    # Path to the ramaze-internal public directory for error-pages and the like.
-    # It acts just as a shadow.
-    trait :public => ( ::Ramaze::BASEDIR / 'proto' / 'public' )
-
-    helper :link, :redirect
-
-    # This finds the template for the given action on the current controller
-    # there are some basic ways how you can provide an alternative path:
-    #
-    # Global.template_root = 'default/path'
-    #
-    # class FooController < Template::Ramaze
-    #   trait :template_root => 'another/path'
-    #   trait :index_template => :foo
-    #
-    #   def index
-    #   end
-    # end
-    #
-    # One feature also used in the above example is the custom template for
-    # one action, in this case :index - now the template of :foo will be
-    # used instead.
-
-    def self.find_template action
-      action = action.to_s
-      custom_template = ancestral_trait["#{action}_template".intern]
-      action = custom_template if custom_template
-
-      first_path =
-        if template_root = ancestral_trait[:template_root]
-          template_root
-        else
-          Global.template_root / Global.mapping.invert[self]
-        end
+module Ramaze
+  module Template
 
-      extensions = ancestral_trait[:template_extensions]
-
-      paths = [ first_path, ancestral_trait[:public], ]
-      paths = paths.map{|pa| File.expand_path(pa / action)}.join(',')
-
-      possible = Dir["{#{paths}}.{#{extensions.join(',')}}"]
-      possible.first
+    %w[ Amrita2 Erubis Haml Liquid Markaby ].each do |const|
+      autoload(const, "ramaze/template/#{const.downcase}")
     end
 
-    private
+    # The superclass for all templates, doesn't do much more than including
+    # Ramaze::Helper and defining #reaction_or_file
 
-    # just call self.class.find_template(action)
-
-    def find_template action
-      self.class.find_template(action)
-    end
+    class Template
+      include Ramaze::Helper
 
-    # the default error-page handler. you can overwrite this method
-    # in your controller and create your own error-template for use.
-    #
-    # Error-pages can be in whatever the templating-engine of your controller
-    # is set to.
-    #   Thread.current[:exception]
-    # holds the exception thrown.
+      class << self
 
-    def error
-      error = Thread.current[:exception]
-      backtrace = error.backtrace[0..20]
-      title = error.message
+        # 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.
 
-      colors = []
-      min = 160
-      max = 255
-      step = -((max - min) / backtrace.size).abs
-      max.step(min, step) do |color|
-        colors << color
-      end
+        def reaction_or_file reaction, file
+          if file
+            File.read(file)
+          elsif reaction.respond_to? :to_str
+            reaction
+          end
+        end
 
-      backtrace.map! do |line|
-        file, lineno, meth = line.scan(/(.*?):(\d+)(?::in `(.*?)')?/).first
-        lines = __caller_lines__(file, lineno, Global.inform_backtrace_size)
-        [ lines, lines.object_id.abs, file, lineno, meth ]
+        def transform controller, options = {}
+          options.values_at(:action, :parameter, :file, :binding)
+        end
       end
-
-      @backtrace = backtrace
-      @colors = colors
-      @title = title
-      require 'coderay'
-      @coderay = true
-    rescue LoadError => ex
-      @coderay = false
     end
   end
 end

data/lib/ramaze/template/amrita2.rb

@@ -4,36 +4,31 @@
 require 'amrita2/template'
 
 module Ramaze::Template
-  class Amrita2 < Template
 
-    # No actions on the controller are serached or called.
-    trait :actionless => true
+  # Is responsible for compiling a template using the Amrita2 templating engine.
 
-    # usual extensions for templates
-    trait :template_extensions => %w[html]
+  class Amrita2 < Template
 
-    class << self
-      include Ramaze::Helper
+    Ramaze::Controller.register_engine self, %w[ amrita ]
 
-      # 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
+      # Takes a controller and the options :action, :parameter, :file and :binding
+      # 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.
 
-        file = find_template(action)
+      def transform controller, options = {}
+        action, parameter, file, bound = *super
 
-        raise Ramaze::Error::Template, "No Template found for #{request.request_path}" unless file
+        raise Ramaze::Error::Template, "No Template found for #{Request.current.request_path}" unless file
 
         template = ::Amrita2::TemplateFile.new(file)
         out = ''
-        template.expand(out, self.new)
+        controller.instance_variable_set('@params', parameter)
+        template.expand(out, controller)
         out
-
-      rescue Object => ex
-        Informer.error ex
-        raise Ramaze::Error::NoAction, "No Action found for #{request.request_path}"
       end
     end
   end

data/lib/ramaze/template/erubis.rb

@@ -4,55 +4,32 @@
 require 'erubis'
 
 module Ramaze::Template
-  class Erubis < Template
-    extend Ramaze::Helper
 
-    # Actions consist of both templates and methods on the controller.
-    trait :actionless => false
+  # Is responsible for compiling a template using the Erubis templating engine.
+
+  class Erubis < Template
 
-    # usual extensions for templates.
-    trait :template_extensions => %w[rhtml rmze xhtml html]
+    Ramaze::Controller.register_engine self, %w[ rhtml ]
 
     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)
+      # Takes a controller and the options :action, :parameter, :file and :binding
+      #
+      # Builds a template out of the method on the controller and the
+      # template-file.
 
-        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
 
-        bound = result.is_a?(Binding) ? result : controller.send(:send, :binding)
-
-        controller.send(:transform, template, bound, file)
-      rescue Object => ex
-        puts ex
-        Informer.error ex
-        ''
+        eruby = ::Erubis::Eruby.new(template)
+        eruby.init_evaluator(:filename => file) if file
+        eruby.result(bound)
       end
     end
-
-    private
-
-    # Transform any String via Erubis, takes an optional binding and filename
-
-    def transform string, bound = binding, file = nil
-      eruby = ::Erubis::Eruby.new(string)
-      eruby.init_evaluator(:filename => file) if file
-      eruby.result(bound)
-    end
   end
 end

data/lib/ramaze/template/ezamar.rb

@@ -0,0 +1,100 @@
+#          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'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Ezamar templating engine.
+
+    class Ezamar < Template
+
+      Ramaze::Controller.register_engine self, %w[ xhtml zmr ]
+
+      trait :transform_pipeline => [ ::Ezamar::Element, ::Ezamar::Morpher, self ]
+      trait :actionless => true
+
+      class << self
+
+        # Takes a controller and the options :action, :parameter, :file and :binding
+        #
+        # 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)
+          alternate, path     = file_template(params.last, controller) if params.size == 1 and action == 'index'
+          file_template, path = file_template(file, controller)
+          ctrl_template       = render_action(controller, action, *params)
+
+          if chosen = to_transform = alternate || file_template || ctrl_template
+            pipeline(chosen, :binding => bound, :path => path)
+          else
+            raise Ramaze::Error::NoAction, "No Action found for `#{action}' on #{controller.class}"
+          end
+        end
+
+        # See if a string is an actual file.
+        #
+        # Answers with the contents and otherwise nil
+
+        def file_template action_or_file, controller
+          path =
+            if File.file?(action_or_file)
+              action_or_file
+            else
+              Controller.find_template(action_or_file, controller)
+            end
+
+          return File.read(path), path
+        rescue
+          nil
+        end
+
+        # Render an action, on a given controller with parameter
+
+        def render_action(controller, action, *params)
+          ctrl_template = controller.send(action, *params).to_s
+        rescue => ex
+          Informer.error(ex)
+          nil
+        end
+
+        # go through the pipeline and call #transform on every object found there,
+        # passing the template at that point.
+        # the order and contents of the pipeline are determined by an array
+        # in trait[:template_pipeline]
+        # the default being [Element, Morpher, self]
+        #
+        # 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)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+# an Element is almost like an Controller, however, instead
+# of connecting actions to templates it is only used in
+# Ramaze::Template::Ezamar and can be used inside the
+# templates of the Controller as a simple wrapper.
+#
+# Example:
+#
+# Your Element called Page:
+#
+#   class Page < Ezamar::Element
+#     def render
+#       %{
+#        <html>
+#          <h1>
+#            #{@hash['title']}
+#          </h1>
+#          #{content}
+#        </html>
+#        }
+#     end
+#   end
+#
+# and one called SideBar
+#
+#   class SideBar < Ezamar::Element
+#     def render
+#       %{
+#         <a href="http://something.com">something</a>
+#        }
+#      end
+#    end
+#
+# and your template (any template for any action):
+#
+#   <Page title="Test">
+#     <SideBar />
+#     <p>
+#       Hello, World!
+#     </p>
+#   </Page>
+#
+# would result in:
+#
+#   <html>
+#     <h1>
+#       Test
+#     </h1>
+#     <p>
+#       Hello, World!
+#     </p>
+#   </html>
+
+class Ezamar::Element
+  attr_accessor :content
+
+  include Ramaze::Helper
+  extend Ramaze::Helper
+
+  helper :redirect, :link
+
+  # this will be called by #transform, passes along the
+  # stuff inside the tags for the element
+
+  def initialize(content)
+    @content = content
+  end
+
+  # The method that will be called upon to render the things
+  # inside the element, you can access #content from here, which
+  # contains the contents between the tags.
+  #
+  # It should answer with a String.
+
+  def render *args
+    @content
+  end
+
+  class << self
+    # transforms all <Element> tags within the string, takes also
+    # a binding to be compatible to the transform-pipeline, won't have
+    # any use for it though.
+    #
+    # It also sets a instance-variable for you called @hash, which
+    # contains the parameters you gave the <Element> tag.
+    # See above for an example of writing and using them.
+
+    def transform string = '', options = {}
+      binding, path = options.values_at(:binding, :path)
+      string = string.to_s
+      matches = string.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)
+      end
+      string
+    end
+
+    # transforms elements like:
+    #   <Page> some content </Page>
+
+    def transform_with_content(string, klass)
+      string.gsub(/<#{klass}( .*?)?>(.*?)<\/#{klass}>/m) do |m|
+        params, content = $1.to_s, $2.to_s
+        finish_transform(klass, params, content)
+      end
+    end
+
+    # transforms elements like:
+    #   <Page />
+
+    def transform_without_content(string, klass)
+      string.gsub(/<#{klass}( .*?)?\/>/) do |m|
+        params = $1.to_s
+        finish_transform(klass, params, content = '')
+      end
+    end
+
+    # find the element, create an instance, pass it the content
+    # check if it responds to :render and set an instance-variable
+    # called @hash to hold the parameters passed to the element.
+    #
+    # Parameters look like:
+    #   <Page foo="true"> bar </Page>
+    #   <Page foo="true" />
+
+    def finish_transform(klass, params, content)
+      instance = constant(klass).new(content)
+
+      hash = demunge_passed_variables(params)
+      instance.instance_variable_set("@hash", hash)
+
+      instance.render
+    rescue => ex
+      Ramaze::Informer.debug(ex.message)
+      ''
+    end
+
+    # basically processes stuff like
+    #   'foo="bar" foobar="baz"'
+    # do NOT pass actual objects that cannot be simply read as a string
+    # here, the information will be lost.
+    #
+    # Exceptions are true, false, Integers and Floats. They will appear
+    # in their real form (this again is also valid for strings that contain
+    # these values in a way that makes Integer/Float possible to parse them)
+    #
+    # Just remember, walk like a duck, talk like a duck.
+
+    def demunge_passed_variables(string)
+      string.scan(/\s?(.*?)="(.*?)"/).inject({}) do |hash, (key, value)|
+        value =
+        case value
+        when 'true'  : true
+        when 'false' : false
+        else
+          Integer(value) rescue Float(value) rescue value
+        end
+      hash.merge key => value
+      end
+    end
+  end
+end