Pistos-ramaze 2009.02 → 2009.04.08

data/lib/ramaze/template/ezamar.rb

@@ -1,42 +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'
-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

@@ -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
-

data/lib/ramaze/template/nagoro.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 '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

@@ -1,14 +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.
-
-module Ramaze
-  module Template
-
-      class None < Template
-        def self.transform action
-          render_method(action)
-        end
-      end
-
-  end
-end

data/lib/ramaze/template/redcloth.rb

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

data/lib/ramaze/template/remarkably.rb

@@ -1,38 +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 'remarkably/engines/html'
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the Remarkably templating engine.
-    # Can be found at: http://rubyforge.org/projects/remarkably
-
-    class Remarkably < Template
-      ENGINES[self] = %w[ rem ]
-
-      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, sets args to action.args and then proceeds
-        # to instance_eval the string inside the action.instance
-
-        def transform_string(string, action)
-          action.instance.instance_eval do
-            args = action.params
-            instance_eval(string)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/template/sass.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 'sass/engine'
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the Sass CSS templating engine.
-    # Can be found at: http://haml.hamptoncatlin.com/
-
-    class Sass < Template
-
-      ENGINES[self] = %w[ sass ]
-
-      class << self
-
-        # Transform via Sass templating engine
-
-        def transform action
-          if response = Response.current
-            response['Content-Type'] = "text/css"
-          end
-          sass = wrap_compile(action)
-          sass.to_css()
-        end
-
-        # Instantiates Sass::Engine with the template and sass_options trait from
-        # the controller.
-
-        def compile(action, template)
-          ::Sass::Engine.new(template, action.controller.trait[:sass_options] || {})
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/template/tagz.rb

@@ -1,79 +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 "tagz"
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the Tagz templating engine.
-    # Can be found at: http://rubyforge.org/projects/codeforpeople/
-    #   gem install tagz
-    # be sure you get version 1.0 or higher
-
-    class Tagz < Template
-      ENGINES[self] = %w[ rb tagz ]
-
-      class << self
-
-        # Entry point for Action#render
-
-        def transform action
-          result, file = result_and_file(action)
-          if file
-            markup = "tagz{#{ file }}"
-            action.instance.extend Methods
-            result = eval markup, action.binding, file
-          end
-          result
-        end
-
-      end
-
-      # Methods defines a host of methods useful inside the context of a view
-      # including print style methods that output content rather that printing to
-      # STDOUT
-
-      module Methods
-        include ::Tagz
-
-      private
-        def << s
-          tagz << s; self
-        end
-
-        def concat *a
-          a.each{|s| tagz << s}; self
-        end
-
-        def puts *a
-          a.each{|elem| tagz << "#{ elem.to_s.chomp }#{ eol }"}
-        end
-
-        def print *a
-          a.each{|elem| tagz << elem}
-        end
-
-        def p *a
-          a.each{|elem| tagz << "#{ Rack::Utils.escape_html elem.inspect }#{ eol }"}
-        end
-
-        def pp *a
-          a.each{|elem| tagz << "#{ Rack::Utils.escape_html PP.pp(elem, '') }#{ eol }"}
-        end
-
-        def eol
-          if response.content_type =~ %r|text/plain|io
-            "\n"
-          else
-            "<br />"
-          end
-        end
-
-        def __ *a
-          concat eol
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/template/tenjin.rb

@@ -1,74 +0,0 @@
-require "tenjin"
-require "tempfile"
-
-# Tenjin does not work with a Binding, so helpers included by the controller
-# will not be automatically available in templates. Instead we add support
-# for popular helpers to its internal Context class to make them available.
-class Tenjin::Context
-  include Ramaze::Helper::Methods
-  helper :link, :sendfile, :flash, :cgi
-end
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the Tenjin templating engine.
-    # Can be found at: http://www.kuwata-lab.com/tenjin/
-    #
-    # Instance variables in your action method are automatically available in
-    # the template:
-    #
-    #  class MainController < Ramaze::Controller
-    #    engine :Tenjin
-    #    def index
-    #      @names = ['Alice', 'Bob', 'Charlie']
-    #      @greeting = 'Hello'
-    #      %q{
-    #      <html><body>
-    #        <h1><?rb for name in @names ?><p>#{@greeting} #{name}</p><?rb end ?></h1>
-    #      </body></html>
-    #      }
-    #    end
-    #  end
-    #
-    # Note that only instance vars are available and methods (including helper methods)
-    # are not available in the template. A few common helpers are made generally available
-    # though by virtue of the modifications to Tenjin::Context at the top of this file.
-
-    class Tenjin < Template
-
-      ENGINES[self] = %w[ rbhtml tenjin ]
-
-      class << self
-        # Transforms an action into the XHTML code for parsing and returns
-        # the result.
-        def transform(action)
-          tenjin = wrap_compile(action)
-          # Tenjin can't deal with a Binding so we construct a hash for it.
-          tenjin.render(context(action))
-        end
-
-        # Return a hash of all instance variables from the action.
-        # For each instance var @foo, we put :foo => @foo in the hash.
-        def context action
-          hash = {}
-          action_binding = action.binding
-          var_names = action.instance.instance_variables
-          var_names.each do |var_name|
-            # Strip the @ from the front of the var name to use as hash key,
-            # then simply use the value of the instance var as the hash value.
-            hash[var_name[1..-1]] = eval(var_name, action_binding)
-          end
-          hash
-        end
-
-        # Compile a template, returning an instance of ::Tenjin::Template.
-        def compile(action, template)
-          tenjin = ::Tenjin::Template.new
-          tenjin.convert(template)
-          return tenjin
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/template/xslt.rb

@@ -1,100 +0,0 @@
-#          Copyright (c) 2007  Stephan Maka  stephan@spaceboyz.net
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'xml/libxml'
-require 'xml/xslt'
-require 'thread'
-
-module Ramaze
-
-  # Use the Gestalt helper to put your controller result
-  # into proper XML form
-  #
-  # TODO:
-  # * Error handling
-  # * Maybe prevent extFunction to be called by HTTP
-  module Template
-    class XSLT < Template
-      ENGINES[self] = %w[ xsl ]
-
-      XSLT_EXT_FUNCTIONS_LOCK = Mutex.new
-
-      class << self
-
-        # Entry point for Action#render
-
-        def transform action
-
-          if options = action.instance.ancestral_trait[:xslt_options] and
-              fun_xmlns = options[:fun_xmlns]
-            # If a controller uses extFunctions, lock the whole
-            # transform action with a Mutex to prevent mixing
-            # extFunction binding and callback of two controller
-            # instances with one fun_xmlns.
-            ext_functions_synchronize do
-              register_ext_functions action.instance, fun_xmlns
-              do_transform action
-            end
-
-          else
-            do_transform action
-          end
-
-        end
-
-        private
-
-        # further abstraction for the transform
-        def do_transform(action)
-          result, file = result_and_file(action)
-
-          xslt = XML::XSLT.new
-          xslt.xsl = action.template
-          xslt.xml = result
-          xslt.serve
-        end
-
-        # Synchronize the block to run with the mutex
-        def ext_functions_synchronize(&block)
-          XSLT_EXT_FUNCTIONS_LOCK.synchronize(&block)
-        end
-
-        # Expose functors
-        def register_ext_functions instance, fun_xmlns
-
-          instance.methods.each do |method|
-            if method =~ /^xslt_.+/
-              method_name = method[5..-1]
-
-              proxy_instance = make_functor(method_name.intern) { |*a|
-                instance.send method.intern, *a
-              }
-
-              XML::XSLT.extFunction method_name.gsub('_', '-'), fun_xmlns, proxy_instance
-            end
-          end
-
-        end
-
-        # Can be replaced by Ruby Facets' Functor pattern
-        def make_functor(m, &block)
-          # Create anonymous class and instantiate;
-          # anonymous because only this one object with this
-          # particular custom method should call &block
-          o = Class.new.new
-
-          class << o
-            # Delayed creation of method
-            def create_method(name, &block)
-              self.class.send(:define_method, name, &block)
-            end
-          end
-
-          o.create_method(m, &block)
-          o
-        end
-
-      end
-    end
-  end
-end