clivecrous-ramaze 0.3.9.5

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

@@ -0,0 +1,76 @@
+#          Copyright (c) 2008 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'
+
+  # This class is responsible for initializing and compiling the template.
+
+  class Template
+
+    # Take a template (anything that responds to ::to_str) and options.
+    # At the moment the only option used is :file, which is used to tell
+    # Kernel::eval how to produce better backtraces.
+
+    def initialize(template, options = {})
+      @template, @options = template, options
+      compile
+    end
+
+    # 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 compile
+      temp = @template.dup
+      start_heredoc = "T" << Digest::SHA1.hexdigest(temp)
+      start_heredoc, end_heredoc = "\n<<#{start_heredoc}\n", "\n#{start_heredoc}\n"
+      bufadd = "_out_ << "
+
+      temp.gsub!(/<%(?!=)\s*(.*?)\s*%>/m,
+            "#{end_heredoc} \\1; #{bufadd} #{start_heredoc}")
+      temp.gsub!(/<\?r\s+(.*?)\s+\?>/m,
+            "#{end_heredoc} \\1; #{bufadd} #{start_heredoc}")
+      temp.gsub!(/<%=\s*(.*?)\s*%>/m,
+            "#{end_heredoc} #{bufadd} (\\1); #{bufadd} #{start_heredoc}")
+
+      @compiled = "_out_ = ''
+      #{bufadd} #{start_heredoc} #{temp} #{end_heredoc}
+      _out_"
+    end
+
+    # Takes a binding and evals it with the previously set options.
+
+    def result(binding)
+      eval(@compiled, binding, @options[:file]).strip
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+begin
+  require 'hpricot'
+rescue LoadError => ex
+  Ramaze::Log.error "Please install hpricot (for example via `gem install hpricot`) to get morphing"
+  puts ex
+end
+
+# 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::TRANSFORM_PIPELINE
+# or do:
+#   Ramaze::Morpher::MORPHS.clear
+#
+# 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::MORPHS
+#
+# For Example:
+#
+#   Morpher::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.
+  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)
+    template = template.to_s
+    hp = Hpricot(template)
+
+    MORPHS.each do |morph, replacement|
+      hp.search("[@#{morph}]") do |elem|
+        expr = elem[morph]
+
+        elem.remove_attribute(morph)
+
+        repl = replacement.
+          sub('%morph', morph).
+          sub('%expression', expr).
+          sub('%content', elem.to_html)
+
+        elem.swap(repl)
+      end
+    end
+
+    hp.to_html
+  end
+end

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

@@ -0,0 +1,31 @@
+#          Copyright (c) 2008 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 Ezamar
+
+  # A transformer for <render /> tags.
+
+  class RenderPartial
+    extend Ramaze::Helper::Partial
+
+    # Renders <render src="/path" [optional="option", ...]> in place.
+    #
+    # Other options than `src` will be transformed to session parameters for the
+    # rendered action to use.
+
+    def self.transform(template)
+      template.gsub!(/<render (.*?) \/>/) do |m|
+        args = Hash[*$1.scan(/(\S+)=["'](.*?)["']/).flatten]
+        if src = args.delete('src')
+          render_partial(src, args)
+        end
+      end
+
+      template
+    end
+
+  end
+end

data/lib/ramaze/template/haml.rb

@@ -0,0 +1,37 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'haml/engine'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Haml templating engine.
+    # Can be found at: http://haml.hamptoncatlin.com/
+
+    class Haml < Template
+
+      ENGINES[self] = %w[ haml ]
+
+      class << self
+
+        # Transform via Haml templating engine
+
+        def transform action
+          haml = wrap_compile(action)
+          haml.to_html(action.instance, action.binding.locals)
+        end
+
+        # Instantiates Haml::Engine with the template and haml_options trait from
+        # the controller.
+
+        def compile(action, template)
+          opts = action.controller.trait[:haml_options] || {}
+          opts.merge! :filename => action.template if action.template
+
+          ::Haml::Engine.new(template, opts)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/liquid.rb

@@ -0,0 +1,36 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'liquid'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Liquid templating engine.
+    # Can be found at: http://home.leetsoft.com/liquid
+
+    class Liquid < Template
+
+      ENGINES[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 transform action
+          template = reaction_or_file(action)
+
+          instance = action.instance
+          hash     = instance.instance_variable_get("@hash") || {}
+          template = ::Liquid::Template.parse(template)
+          options  = instance.ancestral_trait[:liquid_options]
+
+          template.render(hash, options)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/markaby.rb

@@ -0,0 +1,52 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'markaby'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Markaby templating engine.
+    # Can be found at: http://code.whytheluckystiff.net/markaby/
+
+    class Markaby < Template
+      include Ramaze::Helper::Methods
+
+      ENGINES[self] = %w[ mab ]
+
+      class << self
+
+        # Entry point for Action#render
+
+        def transform action
+          result, file = result_and_file(action)
+
+          result = transform_string(file, action) if file
+          result.to_s
+        end
+
+        # Takes a string and action, instance_evals the string inside a mab
+        # block that gets the instance_variables of the original
+        # action.instance passed.
+
+        def transform_string string, action
+          instance = action.instance
+          ivs = extract_ivs(instance)
+
+          instance.send(:mab, ivs) do
+            instance_eval(string)
+          end
+        end
+
+        # Generate a hash from instance-variables
+
+        def extract_ivs(controller)
+          controller.instance_variables.inject({}) do |hash, iv|
+            sym = iv.gsub('@', '').to_sym
+            hash.merge! sym => controller.instance_variable_get(iv)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/nagoro.rb

@@ -0,0 +1,52 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'nagoro'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Nagoro templating engine.
+
+    class Nagoro < Template
+
+      ENGINES[self] = %w[ xhtml nag ]
+
+      PIPES = ::Nagoro::DEFAULT_PIPES.dup
+
+      class << self
+
+        # Transforms an action into the XHTML code for parsing and returns
+        # the result
+        def transform action
+          nagoro = wrap_compile(action)
+          file = action.template || action.method
+          nagoro.result(:file => file, :binding => action.binding)
+        end
+
+        # Use file_or_result instead of reaction_or_file
+        def wrap_compile(action, template = nil)
+          template ||= file_or_result(action)
+          caching_compile(action, template)
+        end
+
+        def file_or_result(action)
+          result = render_method(action).to_s
+
+          if file = action.template
+            return File.new(file)
+          end
+
+          result
+        end
+
+        # Compile a template, applying all transformations from the pipeline
+        # and returning an instance of ::Nagoro::Template
+
+        def compile(action, template)
+          ::Nagoro.compile(template)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/none.rb

@@ -0,0 +1,14 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Template
+
+      class None < Template
+        def self.transform action
+          render_method(action)
+        end
+      end
+
+  end
+end

data/lib/ramaze/template/redcloth.rb

@@ -0,0 +1,25 @@
+require 'redcloth'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the RedCloth templating engine.
+    # Can be found at: http://whytheluckystiff.net/ruby/redcloth/
+
+    class RedCloth < Erubis
+      ENGINES[self] = %w[ redcloth ]
+
+      class << self
+        # Take the action and directly transform it into html by RedCloth
+        def transform(action)
+          restrictions = action.controller.trait[:redcloth_options] || []
+          rules = action.controller.trait[:redcloth_options] || []
+
+          # Erubis -> RedCloth -> HTML
+          redcloth = ::RedCloth.new(super, restrictions)
+          redcloth.to_html(*rules)
+        end
+      end
+    end
+  end
+end