ptomato-ramaze 2009.02

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,39 @@
+#          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

@@ -0,0 +1,34 @@
+--- 
+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/ezamar.rb

@@ -0,0 +1,42 @@
+#          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'
+require 'ramaze/template/ezamar/render_partial'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Ezamar templating engine.
+
+    class Ezamar < Template
+
+      ENGINES[self] = %w[ xhtml zmr ]
+
+      TRANSFORM_PIPELINE = [ ::Ezamar::Element ]
+
+      class << self
+
+        # Transforms an action into the XHTML code for parsing and returns
+        # the result
+        def transform action
+          ezamar = wrap_compile(action)
+          ezamar.result(action.binding)
+        end
+
+        # Compile a template, applying all transformations from the pipeline
+        # and returning an instance of ::Ezamar::Template
+
+        def compile(action, template)
+          file = (action.template || __FILE__)
+
+          TRANSFORM_PIPELINE.each do |tp|
+            template = tp.transform(template)
+          end
+
+          ::Ezamar::Template.new(template, :file => file)
+        end
+      end
+    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/maruku.rb

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

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