ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/view/haml.rb

@@ -0,0 +1,27 @@
+require 'haml'
+require 'haml/util'
+require 'haml/engine'
+
+module Ramaze
+  module View
+    ##
+    # View adapter that allows views to use Haml, for more information see the
+    # following website: http://haml-lang.com/
+    #
+    module Haml
+      def self.call(action, string)
+        options = action.options
+
+        if haml_options = action.instance.ancestral_trait[:haml_options]
+          options = options.merge(haml_options)
+        end
+
+        action.options[:filename] = (action.view || '(haml)')
+        haml = View.compile(string){|s| ::Haml::Engine.new(s, options) }
+        html = haml.to_html(action.instance, action.variables)
+
+        return html, 'text/html'
+      end
+    end # Haml
+  end # View
+end # Ramaze

data/lib/ramaze/view/liquid.rb

@@ -0,0 +1,99 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
+require 'liquid'
+
+module Ramaze
+  module View
+    # Liquid is a smarty-style templating engine that restricts the usage of
+    # code inside templates. This is mostly helpful if you want to let users
+    # submit templates but prevent them from running arbitrary code.
+    #
+    # Liquid offers a pipe-like syntax for chaining operations on objects.
+    # Any instance variable from your Controller is available as a variable
+    # inside Liquid, so be sensitive about what data you provide.
+    #
+    # If you want to allow partials you can provide a kind of virtual
+    # filesystem that contains partials. These can be rendered using the
+    # Liquid `{% include 'name' %}` tag. The include tag has no relation to the
+    # Ramaze::Helper::Render, it simply inlines the file.
+    #
+    # To tell Liquid where to find partials, you have to set the file_system.
+    # The naming-convention for liquid-partials is to use a '_' prefix to the
+    # filename and the '.liquid' filename extension. The names of partials
+    # are restricted to ASCII alpha-numeric characters and underscores. You
+    # can also use '/' to use templates located in deeper directories.
+    # The partial has access to the same variables as the template including
+    # it.
+    #
+    # @example setting file_system
+    #   template_path = './partials/'
+    #   Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
+    #
+    # @example using include
+    #   {% include 'foo' %}
+    #   {% include 'bar/foo' %}
+    #
+    # This will include the files located at './partials/_foo.liquid' and
+    # './partials/bar/_foo.liquid'.
+    #
+    # This functionality gets even more interesting if you customize it with
+    # your own virtual file-system, you can use anything that responds to
+    # `#read_template_file(path)`.
+    # That way you can even fetch templates from a database or instruct Liquid
+    # to allow you access to your own templates in the '/views' directory.
+    module Liquid
+
+      # Liquid requires the variable keys to be strings, most likely for
+      # security resons (don't allow arbitrary symbols).
+      def self.call(action, string)
+        action.sync_variables(action)
+        variables = {}
+        action.variables.each{|k,v| variables[k.to_s] = v }
+
+        liquid = View.compile(string){|s| ::Liquid::Template.parse(s) }
+        html = liquid.render(variables)
+
+        return html, 'text/html'
+      end
+
+      class Tag < ::Liquid::Tag
+        def initialize(tag_name, arg, tokens)
+          super
+          @arg = arg.strip
+        end
+      end
+
+      # Liquid has intentionally? no support for binding, in order to use
+      # helpers you have to register them as tags.
+      #
+      # Creating a tag needs boilerplate, so we reduce that for your
+      # convenience.
+      #
+      # This is not the most performant way, it seems like Liquid uses
+      # initialize to compile templates and gives you the chance to process the
+      # arguments to the tag only once, but if you want that please contribute.
+      #
+      # Further below are a couple of tags that map to the most common helpers,
+      # this also needs contribution as I simply don't have the time to write
+      # all of that and invent a consistent syntax.
+      def self.register_tag(name, helper, &block)
+        klass = Class.new(Tag)
+        klass.send(:include, helper)
+        klass.send(:define_method, :render, &block)
+
+        ::Liquid::Template.register_tag(name, klass)
+      end
+
+      # {% route index %}
+      register_tag('route', Ramaze::Helper::Link) do |context|
+        Ramaze::Current.action.node.route(@arg)
+      end
+
+      # {% anchor "The index" index %}
+      register_tag('anchor', Ramaze::Helper::Link) do |context|
+        @arg =~ /^(['"])(.*?)\1\s+(.*)/
+        Ramaze::Current.action.node.anchor($2, $3)
+      end
+    end # Liquid
+  end # View
+end # Ramaze

data/lib/ramaze/view/lokar.rb

@@ -0,0 +1,18 @@
+require 'lokar'
+
+module Ramaze
+  module View
+    ##
+    # Allows views to use Lokar as the template engine. See the following
+    # website for more information: https://github.com/Zoxc/Lokar
+    #
+    module Lokar
+      def self.call(action, string)
+        compiled = View.compile(string){|s| ::Lokar.compile(s, action.view || __FILE__) }
+        html = action.instance.instance_eval(&compiled).join
+
+        return html, 'text/html'
+      end
+    end # Helper
+  end # View
+end # Ramaze

data/lib/ramaze/view/mustache.rb

@@ -0,0 +1,46 @@
+require 'mustache'
+
+module Ramaze
+  module View
+    # Binding to Mustache templating engine.
+    #
+    # Mustache uses user-defined class for rendering. Ramaze overwrites value,
+    # if controller defined same name variable as method that class defined.
+    #
+    # @see http://github.com/defunkt/mustache
+    module Mustache
+      class RamazeContext < ::Mustache::Context
+        def escapeHTML(str)
+          str.escape(:html)
+        end
+      end
+
+      def self.call(action, string)
+        context, path, ext = class_defined?(action)
+
+        action.sync_variables(action)
+        action.variables.each { |k, v| context[k.to_sym] = v }
+
+        view = View.compile(string) { |s| ::Mustache::Template.new(s) }
+        html = view.render(context)
+
+        return html, 'text/html'
+      end
+
+      def self.class_defined?(action)
+        return RamazeContext.new(nil), nil, nil unless action.view
+
+        path = File.dirname(action.view)
+
+        klass = if FileTest.exist?(File.join(path, "#{action.name}.rb"))
+          require File.join(path, action.name)
+          ::Object.const_get(::Mustache.classify(action.name)) # or eval?
+        else
+          ::Mustache
+        end
+
+        return RamazeContext.new(klass.new), path, View.exts_of(self).first
+      end
+    end # Mustache
+  end # View
+end # Ramaze

data/lib/ramaze/view/nagoro/render_partial.rb

@@ -0,0 +1,32 @@
+require 'innate/helper/render'
+
+module Nagoro
+  module Pipe
+    # Pipe that transforms <render /> tags.
+    #
+    # the src parameter in the render tag will be used as first parameter to
+    # render_partial, all other parameters are passed on as +variables+.
+    #
+    # Example calling render_partial('hello'):
+    #   <render src="hello" />
+    #
+    # Example calling render_partial('hello', 'tail' => 'foo'):
+    #   <render src="hello" tail="foo" />
+    #
+    class RenderPartial < Base
+      include Innate::Helper::Render
+
+      def tag_start(tag, attrs)
+        if tag == 'render' and action_name = attrs.delete('src')
+          append(render_partial(action_name, attrs))
+        else
+          super
+        end
+      end
+
+      def tag_end(tag)
+        super unless tag == 'render'
+      end
+    end
+  end
+end

data/lib/ramaze/view/nagoro.rb

@@ -0,0 +1,44 @@
+require 'nagoro'
+require 'ramaze/view/nagoro/render_partial'
+
+module Ramaze
+  module View
+    # Binding to the Nagoro templating engine.
+    #
+    # To pipe your template through tidy you have to use:
+    #
+    #   Ramaze::View::Nagoro.options.tidy = true
+    #
+    # @see http://github.com/manveru/nagoro
+    module Nagoro
+      include Optioned
+
+      options.dsl do
+        o "Pipes to pass the template through",
+          :pipes, ::Nagoro::DEFAULT_PIPES
+
+        o "Use tidy to cleanup the rendered template",
+          :tidy, false
+      end
+
+      def self.call(action, string)
+        default_options = {
+          :pipes     => options.pipes,
+          :filename  => action.view,
+          :binding   => action.binding,
+          :variables => action.variables
+        }
+
+        render_options = default_options.merge(action.options)
+
+        if options.tidy
+          html = ::Nagoro.tidy_render(string.to_s, render_options)
+        else
+          html = ::Nagoro.render(string.to_s, render_options)
+        end
+
+        return html, 'text/html'
+      end
+    end # Nagoro
+  end # View
+end # Ramaze

data/lib/ramaze/view/remarkably.rb

@@ -0,0 +1,22 @@
+require 'remarkably'
+require 'remarkably/engines/html'
+
+module Ramaze
+  module View
+    module Remarkably
+      def self.call(action, string)
+        string = transform_string(action, string) if action.view
+        html = string.to_s
+
+        return html, 'text/html'
+      end
+
+      def self.transform_string(action, string)
+        action.instance.instance_eval do
+          args = action.params
+          instance_eval(string)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/view/sass.rb

@@ -0,0 +1,22 @@
+require 'haml'
+require 'sass'
+require 'haml/util'
+
+module Ramaze
+  module View
+    module Sass
+      def self.call(action, string)
+        options = action.options
+
+        if sass_options = action.instance.ancestral_trait[:sass_options]
+          options = options.merge(sass_options)
+        end
+
+        sass = View.compile(string){|s| ::Sass::Engine.new(s, options) }
+        css = sass.to_css
+
+        return css, 'text/css'
+      end
+    end
+  end
+end

data/lib/ramaze/view/slim.rb

@@ -0,0 +1,43 @@
+require 'slim'
+
+module Innate
+  module View
+    ##
+    # View adapter for the Slim template engine. For more information about Slim
+    # see the following page: https://github.com/stonean/slim
+    #
+    # @example
+    #  class MainController < Ramaze::Controller
+    #    map    '/'
+    #    engine :slim
+    #
+    #    def index
+    #      # Create some data for the view and render it.
+    #    end
+    #  end
+    #
+    # @since 19-01-2012
+    #
+    module Slim
+      ##
+      # Compiles the view and returns the HTML and mime type.
+      #
+      # @since 19-01-2012
+      # @param [Innate::Action] action The action for which to compile/render
+      #  the view.
+      # @param  [String] string The content of the view.
+      # @return [Array] The HTML and MIME type.
+      #
+      def self.call(action, string)
+        filename = action.view || action.method
+        slim     = View.compile(string) do |str|
+          ::Slim::Template.new(filename) { str }
+        end
+
+        html = slim.render(action.instance)
+
+        return html, Response.mime_type
+      end
+    end # Slim
+  end # View
+end # Innate

data/lib/ramaze/view/slippers.rb

@@ -0,0 +1,51 @@
+require 'slippers'
+
+module Ramaze
+  module View
+    ##
+    # View adapter for Slippers, see the website of Slippers for more
+    # information: http://starapor.github.com/slippers/
+    #
+    #
+    module Slippers
+      def self.call(action, string)
+        slippers = View.compile(string) do |s|
+          ::Slippers::Engine.new(s, :template_group => template_group(action))
+        end
+
+        object_to_render = ::Slippers::BindingWrapper.new(action.instance.binding)
+        html             = slippers.render(object_to_render)
+
+        return html, 'text/html'
+      end
+
+      private
+
+      def self.template_group(action)
+        subtemplates = action.instance.ancestral_trait[:slippers_options] || {}
+        missing_template_handler = action.instance.ancestral_trait[
+          :slippers_missing_template_handler
+        ]
+        default_string = action.instance.ancestral_trait[
+          :slippers_default_string
+        ]
+
+        views = action.instance.options[:views].map do |view|
+          "#{action.instance.options[:roots]}/#{view}"
+        end
+
+        super_group = ::Slippers::TemplateGroup.new(
+          :templates                => subtemplates,
+          :missing_template_handler => missing_template_handler,
+          :default_string           => default_string
+        )
+
+        ::Slippers::TemplateGroupDirectory.new(
+          views, :super_group       => super_group,
+          :missing_template_handler => missing_template_handler,
+          :default_string           => default_string
+        )
+      end
+    end # Slippers
+  end # View
+end # Ramaze

data/lib/ramaze/view/tagz.rb

@@ -0,0 +1,67 @@
+require 'tagz'
+
+module Ramaze
+  module View
+    module Tagz
+      def self.call(action, string)
+        return string, 'text/html' unless action.view
+
+        markup = "tagz{#{string}}"
+        action.instance.extend(Ramaze::View::Tagz::Methods)
+        binding = action.binding
+
+        html = eval(markup, binding, action.view)
+
+        return html, 'text/html'
+      end
+
+      # 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 do |elem|
+            tagz << "#{ Rack::Utils.escape_html elem.inspect }#{ eol }"
+          end
+        end
+
+        def pp(*a)
+          a.each do |elem|
+            tagz << "#{ Rack::Utils.escape_html PP.pp(elem, '') }#{ eol }"
+          end
+        end
+
+        def eol
+          if response.content_type =~ %r|text/plain|io
+            "\n"
+          else
+            "<br />"
+          end
+        end
+
+        def __(*a)
+          concat eol
+        end
+      end
+    end # Tagz
+  end # View
+end # Ramaze

data/lib/ramaze/view/tenjin.rb

@@ -0,0 +1,32 @@
+require 'tenjin'
+
+module Ramaze
+  module View
+    module Tenjin
+      def self.call(action, string)
+        tenjin = View.compile(string){|s|
+          template = ::Tenjin::Template.new
+          template.convert(s)
+          template
+        }
+
+        html = tenjin.ramaze_render(action.binding)
+
+        return html, 'text/html'
+      end
+    end
+  end
+end
+
+module Tenjin
+  class Template
+    # This method allows us to use tenjin with a binding, so helper methods are
+    # available instead of only instance variables.
+    # The big issue with this approach is that the original
+    # Tenjin::ContextHelper is not available here. Patches welcome.
+    def ramaze_render(binding)
+      code = "_buf = #{init_buf_expr}; #{@script}; _buf.to_s"
+      _buf = eval(code, binding, @filename || '(tenjin)')
+    end
+  end
+end

data/lib/ramaze/view.rb

@@ -0,0 +1,35 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
+
+module Ramaze
+  View = Innate::View
+
+  # This is a container module for wrappers of templating engines and handles
+  # lazy requiring of needed engines.
+  module View
+    # Combine Kernel#autoload and Innate::View::register
+    def self.auto_register(name, *exts)
+      autoload(name, "ramaze/view/#{name}".downcase)
+      register("Innate::View::#{name}", *exts)
+    end
+
+    # Engines provided by Innate are:
+    # ERB, Etanni, None
+    auto_register :Erector,    :erector
+    auto_register :Erubis,     :erubis,  :rhtml
+    auto_register :Ezamar,     :zmr
+    auto_register :Gestalt,    :ges
+    auto_register :Haml,       :haml
+    auto_register :Less,       :lss, :less
+    auto_register :Liquid,     :liquid
+    auto_register :Lokar,      :lok
+    auto_register :Nagoro,     :nag
+    auto_register :Remarkably, :rem
+    auto_register :Sass,       :sass
+    auto_register :Slim,       :slim
+    auto_register :Tagz,       :tagz
+    auto_register :Tenjin,     :rbhtml, :tenjin
+    auto_register :Slippers,   :st
+    auto_register :Mustache,   :mustache, :mt
+  end # View
+end # Ramaze