ramaze 2009.03 → 2009.04

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

@@ -1,76 +0,0 @@
-#          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

@@ -1,135 +0,0 @@
-#          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

@@ -1,39 +0,0 @@
-#          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.
-  #
-  # Setup:
-  #
-  #     pipeline = Ramaze::Template::Ezamar::TRANSFORM_PIPELINE
-  #     pipeline.put_after(::Ezamar::Element, ::Ezamar::RenderPartial)
-  #     pipline.uniq!
-  #
-  # See /examples/basic/partial.rb for usage.
-
-  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/ezamar/textpow.syntax

@@ -1,34 +0,0 @@
---- 
-name: HTML (Ezamar)
-fileTypes:
-- xhtml
-scopeName: text.html.ruby
-uuid: 45D7E1FC-7D0B-4205-A1A2-3D10BB555A5C
-foldingStartMarker: |-
-  (?x)
-  		(<(?i:head|body|table|thead|tbody|tfoot|tr|div|select|fieldset|style|script|ul|ol|form|dl)\b.*?>
-  		|<!--(?!.*-->)
-  		|\{\s*($|\?>\s*$|//|/\*(.*\*/\s*$|(?!.*?\*/)))
-  		)
-patterns:
-- name: source.ruby.ezamar.embedded.html
-  captures:
-    "0":
-      name: punctuation.section.embedded.ruby
-  begin: "<?r"
-  end: "?>"
-  patterns:
-  - name: comment.line.number-sign.ruby
-    captures:
-      "1":
-        name: punctuation.definition.comment.ruby
-    match: (#).*?(?=-?\?>)
-  - include: source.ruby.ezamar
-- include: text.html.basic
-foldingStopMarker: |-
-  (?x)
-  		(</(?i:head|body|table|thead|tbody|tfoot|tr|div|select|fieldset|style|script|ul|ol|form|dl)>
-  		|^\s*-->
-  		|(^|\s)\}
-  		)
-keyEquivalent: ^~R

data/lib/ramaze/template/haml.rb

@@ -1,37 +0,0 @@
-#          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

@@ -1,36 +0,0 @@
-#          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

@@ -1,52 +0,0 @@
-#          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/maruku.rb

@@ -1,34 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'maruku'
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the Ezamar templating engine.
-
-    class Maruku < Template
-
-      ENGINES[self] = %w[ mkd ]
-
-      class << self
-
-        # Transforms an action into the XHTML code for parsing and returns
-        # the result
-        def transform(action)
-          maruku = wrap_compile(action)
-          maruku.to_html
-        end
-
-        # Compile a template, applying all transformations from the pipeline
-        # and returning an instance of ::Ezamar::Template
-
-        def compile(action, template)
-          ::Maruku.new(template)
-        end
-      end
-    end
-  end
-end
-