ramaze 0.0.6

data/lib/ramaze/template.rb

@@ -0,0 +1,102 @@
+#          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'
+
+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
+
+      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
+    end
+
+    private
+
+    # just call self.class.find_template(action)
+
+    def find_template action
+      self.class.find_template(action)
+    end
+
+    # 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.
+
+    def error
+      error = Thread.current[:exception]
+      backtrace = error.backtrace[0..20]
+      title = error.message
+
+      colors = []
+      min = 160
+      max = 255
+      step = -((max - min) / backtrace.size).abs
+      max.step(min, step) do |color|
+        colors << color
+      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 ]
+      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

@@ -0,0 +1,40 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'amrita2/template'
+
+module Ramaze::Template
+  class Amrita2 < Template
+
+    # No actions on the controller are serached or called.
+    trait :actionless => true
+
+    # usual extensions for templates
+    trait :template_extensions => %w[html]
+
+    class << self
+      include Ramaze::Helper
+
+      # 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
+
+        file = find_template(action)
+
+        raise Ramaze::Error::Template, "No Template found for #{request.request_path}" unless file
+
+        template = ::Amrita2::TemplateFile.new(file)
+        out = ''
+        template.expand(out, self.new)
+        out
+
+      rescue Object => ex
+        Informer.error ex
+        raise Ramaze::Error::NoAction, "No Action found for #{request.request_path}"
+      end
+    end
+  end
+end

data/lib/ramaze/template/erubis.rb

@@ -0,0 +1,58 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'erubis'
+
+module Ramaze::Template
+  class Erubis < 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[rhtml rmze xhtml html]
+
+    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)
+
+        template =
+          if file
+            File.read(file)
+          elsif result.respond_to? :to_str
+            result
+          end
+
+        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
+        ''
+      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/haml.rb

@@ -0,0 +1,65 @@
+#          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 => {}
+    }
+
+    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)
+
+        template =
+          if file
+            File.read(file)
+          elsif result.respond_to? :to_str
+            result
+          end
+
+        return '' unless template
+
+        controller.send(:transform, template)
+      rescue Object => ex
+        puts ex
+        Informer.error ex
+        ''
+      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/haml/actionview_stub.rb

@@ -0,0 +1,20 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+# stub, in case the requires for that active_* stuff of Haml doesn't fail
+# but we are not running Rails ;)
+
+module ActionView
+  class Base
+
+    # stub
+
+    def concat
+    end
+
+    # stub
+
+    def form_tag
+    end
+  end
+end

data/lib/ramaze/template/liquid.rb

@@ -0,0 +1,74 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+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 => {}
+
+    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
+
+        template =
+          if file
+            File.read(file)
+          elsif result.respond_to? :to_str
+            result
+          end
+
+        return '' unless template
+
+        controller.send(:transform, template)
+      rescue Object => ex
+        puts ex
+        Informer.error ex
+        ''
+      end
+    end
+
+    private
+
+    # 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)
+    end
+  end
+end

data/lib/ramaze/template/markaby.rb

@@ -0,0 +1,68 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'markaby'
+
+module Ramaze::Template
+  class Markaby < 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[mab]
+
+    private
+
+    # use this inside your controller to directly build Markaby
+    # Refer to the Markaby-documentation and testsuite for more examples.
+    # Usage:
+    #   mab { h1 "Apples & Oranges"}                    #=> "<h1>Apples &amp; Oranges</h1>"
+    #   mab { h1 'Apples', :class => 'fruits&floots' }  #=> "<h1 class=\"fruits&amp;floots\">Apples</h1>"
+
+    def mab(*args, &block)
+      builder = ::Markaby::Builder
+      builder.extend(Ramaze::Helper)
+      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

data/lib/ramaze/template/ramaze.rb

@@ -0,0 +1,177 @@
+#          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'
+require 'ramaze/template/ramaze/element'
+require 'ramaze/template/ramaze/morpher'
+
+module Ramaze::Template
+
+  # The usual Template for use of Ramaze.
+  # It supports erb-style interpolation and a pipeline for the transform
+
+  class Ramaze < Template
+
+    # Actions consist of both templates and methods on the controller.
+    trait :actionless => false
+
+    # Usual extensions for templates.
+    trait :template_extensions => %w[rmze xhtml rhtml html]
+
+    # Each Object in this Array will be called :transform upon.
+    trait :transform_pipeline => [ Element, Morpher, self ]
+
+    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.send(:render, action, *params)
+      end
+
+      # in case someone wants to call directly (pipeline)
+
+      def transform(template, bound)
+        self.new.send(:transform, template, bound)
+      end
+    end
+
+    private
+
+    # render an action
+    # this looks up the file depending on your Global.template_root
+    # and also takes the mapping of the controller in account.
+    # To use the exception of method_missing as flow-control might seem odd,
+    # but it works perfect for method_missing defined in the controller...
+    # otherwise one has to modify respond_to?... maybe add a special take-all method?
+    #
+    # for example:
+    # / => FooController, /main => MainController
+    # an action to /bar would search directly in the template_root for a file called bar
+    # and the extensions rmze, xhtml or html (in that order)
+    # if it finds a file it will transform it and return the result
+    # otherwise nothing happens
+    #
+    # TODO:
+    #   - maybe add some way to define a custom template-file per action via traits
+    #     trait :methodname_template => :foo
+    #     would point to the template-file of action :foo - template_root/foo.ext
+    #   - add extensive tests!
+    #
+
+    def render(action, *params)
+      alternate = render_template(params.last) if params.size == 1 and action == 'index'
+      file_template = render_template(action, *params)
+      ctrl_template = render_action(action, *params)
+
+      pipeline(alternate || file_template || ctrl_template)
+    end
+
+    # Render an action, usually a method on the controller.
+
+    def render_action(action, *params)
+      ctrl_template = send(action, *params).to_s
+    rescue => e
+      Informer.error e unless e.message =~ /undefined method `#{Regexp.escape(action.to_s)}'/
+
+      unless caller.select{|bt| bt[/`render_action'/]}.size > 3
+        Dispatcher.respond_action([action, *params].join('/'))
+        ctrl_template = response.out
+      end
+    end
+
+    # Render the template.
+
+    def render_template(action, *params)
+      File.read(find_template(action)) rescue 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]
+
+    def pipeline(template)
+      transform_pipeline = ancestral_trait[:transform_pipeline]
+
+      transform_pipeline.inject(template) do |memo, current|
+        current.transform(memo, binding)
+      end
+    end
+
+    # transform a String to a final xhtml
+    #
+    # 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.
+    #
+    # Warning:
+    # the variables used in here have the schema _variable_ to make it harder to break stuff
+    # however, you should take care.
+    # At the time of writing, the variables used are:
+    # _start_heredoc_, _end_heredoc_, _template_, _out_, _file_ and _bufadd_
+    # However, you may reuse _ivs_ if you desperatly need it and just can't live without.
+    #
+
+    def transform(_template_, _binding_ = binding)
+      _start_heredoc_ = "T" << Digest::SHA1.hexdigest(_template_)
+      _start_heredoc_, _end_heredoc_ = "\n<<#{_start_heredoc_}\n", "\n#{_start_heredoc_}\n"
+      _bufadd_ = "_out_ << "
+
+      _file_, _template_ = _template_, File.read(_template_) if File.file?(_template_)
+
+      _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_}")
+
+
+      # this one should not be used until we find and solution
+      # that allows for stuff like
+      # #[@foo]!
+      # we just don't allow anything except space or newline
+      # after the expression #[] to make it sane
+      #_template_.gsub!(/#\[(.*?)\]\s*$/) do |m|
+      #  "#{_end_heredoc_} #{_bufadd_} (#{$1}); #{_bufadd_} #{_start_heredoc_}"
+      #end
+
+      _template_ = [_bufadd_, _start_heredoc_, _template_, _end_heredoc_].join(' ')
+      _out_ = eval(*["_out_ = []; #{_template_}; _out_", _binding_, _file_].compact)
+
+      _out_.map! do |line|
+        line.to_s.chomp
+      end
+
+      _template_ = _out_.join.strip
+    rescue Object => ex
+      Informer.error "something bad happened while transformation"
+      Informer.error ex
+      #raise Error::Template, "Problem during transformation for: #{request.request_path}"
+      {ex.message => _template_}.inspect
+    end
+
+  end
+end