malline 1.0.2 → 1.1.0

data/README

@@ -1,4 +1,4 @@
-Malline 1.0.2
+Malline 1.1.0
 =============
 
 See documentation on http://www.malline.org/
@@ -7,18 +7,18 @@ Copyright © 2007,2008 Riku Palomäki, riku@palomaki.fi
 Malline is released under GNU Lesser General Public License.
 
 
-Example template file images.mn:
+Example Rails template file images.html.mn:
 
-html do
-	_render :partial => 'head'
-	body do
-		div.images! "There are some images:" do
-			images.each do |im|
-				a(:href => img_path(im)) { img :src => im.url }
-				span.caption im.caption
+	xhtml do
+		_render :partial => 'head'
+		body do
+			div.images! "There are some images:" do
+				images.each do |im|
+					a(:href => img_path(im)) { img :src => im.url }
+					span.caption im.caption
+				end
+				_"No more images"
 			end
-			_"No more images"
+			div.footer! { _render :partial => 'footer' }
 		end
-		div.footer! { _render :partial => 'footer' }
 	end
-end

data/lib/malline.rb

@@ -17,90 +17,91 @@
 
 require 'malline/view_proxy.rb'
 require 'malline/view_wrapper.rb'
-require 'malline/view_xhtml.rb'
 require 'malline/erb_out.rb'
-require 'malline/form_builder.rb'
 require 'malline/template.rb'
+require 'malline/plugin.rb'
+require 'malline/plugins/xhtml.rb'
 
 module Malline
-	VERSION = '1.0.2'
+	# Always form ^\d+\.\d+\.\d+(-[^\s]*)?$
+	VERSION = '1.1.0'
 
-	# Template-handler class that is registered to ActionView and initialized by it.
+	# Malline handler, always use Malline engine with this
+	# 	handler = Malline.new @view, :strict => false
+	# 	handler.
 	class Base
-		# Default options for new instances, can be changed with setopt
-		@@options = { :strict => true, :xhtml => true, :encoding => 'UTF-8', :lang => 'en', :form_for_proxy => true }
-		attr_reader :view
+		attr_accessor :malline
+
+		# Default options, can be changed with setopt
+		@@options = {
+			:strict => true,
+			:xhtml => true,
+			:encoding => 'UTF-8',
+			:lang => 'en',
+			:form_for_proxy => true
+		}
 
 		# First parameter is the view object (if any)
 		# Last parameter is optional options hash
-		def initialize(*opts)
+		def initialize *opts
 			@options = @@options.dup
 			@options.merge! opts.pop if opts.last.is_a?(Hash)
 
 			@view = opts.shift || Class.new
-			unless @view.is_a?(ViewWrapper)
-				@view.extend ViewWrapper
-				@view.malline @options
-				Malline::XHTML.load_plugin self if @options[:xhtml]
-			else
-				@view.malline @options
-			end
+			@view.extend ViewWrapper unless @view.is_a?(ViewWrapper)
+			@malline = @view.malline @options
+		end
 
-			if @options[:form_for_proxy]
-				begin
-					ActionView::Base.default_form_builder = ::Malline::FormBuilder
-				rescue NameError
-				end
-			end
+		# Get the current filename
+		def path 
+			@view.malline.path
 		end
 
-		def set_path path
-			@view.malline.path = path
+		def path= npath
+			@view.malline.path = npath
 		end
 
+		# for example:
+		# 	setopt :strict => false
+		#
+		# or:
+		# 	setopt :strict => false
+		#		something
+		# 	setopt :strict => true do
+		#   	something strict
+		# 	end
 		def self.setopt hash
-			output = nil
-			if block_given?
-				o = @@options.dup
-				@@options.merge!(hash) if hash
-				begin
-					output = yield
-				ensure
-					@@options = o
-				end
-			else
-				@@options.merge!(hash)
-			end
-			output
+			return @@options.merge!(hash) unless block_given?
+			old = @@options.dup
+			@@options.merge! hash if hash
+			yield
+		ensure
+			@@options = old if old
 		end
 
-		# n is there to keep things compatible with Markaby
-		def render tpl = nil, local_assigns = {}, n = nil, &block
+		def render tpl = nil, local_assigns = {}, &block
 			add_local_assigns local_assigns
-			@view.malline_is_active = true
 			@view.malline.run tpl, &block
 		end
 
 		def self.render tpl = nil, local_assigns = {}, &block
-			self.new.render(tpl, local_assigns, &block)
+			self.new.render tpl, local_assigns, &block
 		end
 
-		# TODO: These should also be able to disable
-		def definetags *tags
-			tags.each do |tag|
-				eval %{
-					def @view.#{tag}(*args, &block)
-						tag!('#{tag}', *args, &block)
-					end
-				}
-			end
+		def definetags *args
+			@view.malline.definetags *args
+		end
+
+		def definetags! *args
+			@view.malline.definetags! *args
 		end
 
 		private
+		# Define hash as instance variables, for example { :foo => 'bar' }
+		# will work as @foo == 'bar' and foo == 'bar'
 		def add_local_assigns l
 			@view.instance_eval do
 				l.each { |key, value| instance_variable_set "@#{key}", value }
-				evaluate_assigns if respond_to?(:evaluate_assigns, true)
 				class << self; self; end.send(:attr_accessor, *(l.keys))
 			end
 		end

data/lib/malline/adapters/rails-2.0.rb

@@ -0,0 +1,72 @@
+# Copyright © 2007,2008 Riku Palomäki
+#
+# This file is part of Malline.
+#
+# Malline is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Malline is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Malline.  If not, see <http://www.gnu.org/licenses/>.
+
+ActionView::Base.register_template_handler 'mn', Malline::Base
+module ActionView
+	# We need to redefine some ActionView::Base methods, Since Rails 2.0 doesn't
+	# offer any better way to do some things.
+	class Base
+		alias_method :orig_render_template, :render_template
+		# We want to save the name of the current file to @current_tpl_path,
+		# because then the error backtrace from Rails will include the
+		# name of the file. I didn't find better way to get this
+		def render_template template_extension, template, file_path = nil, *rest
+			@current_tpl_path = file_path
+			orig_render_template(template_extension, template, file_path, *rest)
+		end
+
+		alias_method :orig_compile_and_render_template, :compile_and_render_template
+		def compile_and_render_template handler, *rest
+			if self.respond_to? :is_malline?
+				old, @malline_is_active = is_malline?, false
+				output = orig_compile_and_render_template handler, *rest
+				@malline_is_active = old
+				output
+			else
+				@malline_is_active = false
+				orig_compile_and_render_template handler, *rest
+			end
+		end
+
+		alias_method :orig_delegate_render, :delegate_render
+		# Update the current file to malline and tell Malline to be deactivated
+		# if there is a non-Malline partial inside Malline template.
+		def delegate_render(handler, template, local_assigns)
+			old = is_malline?
+			tmp = if handler == Malline::Base
+				h = handler.new(self)
+				h.path = @current_tpl_path if @current_tpl_path
+				@malline_is_active = true
+				h.render(template, local_assigns)
+			else
+				@malline_is_active = false
+				orig_delegate_render(handler, template, local_assigns)
+			end
+			@malline_is_active = old
+			tmp
+		end
+	end
+end
+
+module Malline::ViewWrapper
+	# Activate Malline if we are not using ActionView::Base or if
+	# the current template is a Malline template
+	def is_malline?
+		@malline_is_active.nil? ? true : @malline_is_active
+	end
+end
+

data/lib/malline/adapters/rails-2.1.rb

@@ -0,0 +1,103 @@
+# Copyright © 2007,2008 Riku Palomäki
+#
+# This file is part of Malline.
+#
+# Malline is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Malline is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Malline.  If not, see <http://www.gnu.org/licenses/>.
+
+module Malline
+	# Malline template handler for Rails 2.1
+	#
+	# We use Compilable-interface, even though Malline templates really doesn't
+	# compile into anything, but at least template files won't always be re-read
+	# from files. Builder templates (.builder|.rxml) also use this interface.
+	class RailsHandler < ActionView::TemplateHandler
+		include ActionView::TemplateHandlers::Compilable
+
+		# We have three lines framework code before real template code in
+		# 'compiled code'
+		def self.line_offset
+			3
+		end
+
+		# Compiles the template, i.e. return a runnable ruby code that initializes
+		# a new Malline::Base objects and renders the template.
+		def compile template
+			path = template.path.gsub('\\', '\\\\\\').gsub("'", "\\\\'")
+			"__malline_handler = Malline::Base.new self
+			malline.path = '#{path}'
+			__malline_handler.render do
+				#{template.source}
+			end"
+		end
+
+		# Get the rendered fragment contents
+		def cache_fragment block, name = {}, options = nil
+			@view.fragment_for(block, name, options) do
+				eval("__malline_handler.rendered", block.binding)
+			end
+		end
+	end
+end
+
+module Malline::ViewWrapper
+	# Activate Malline if we are not using ActionView::Base or if
+	# the current template is a Malline template
+	def is_malline?
+		!(is_a?(ActionView::Base) && ActionView::Template.handler_class_for_extension(
+				current_render_extension) != Malline::RailsHandler)
+	end
+end
+
+# Rails has a bug with current_render_extension, lets fix it
+if ActionView.const_defined?('Renderer')
+	module ActionView::Renderer
+		alias_method :orig_render, :render
+		def render *args
+			out = orig_render *args
+			@view.current_render_extension = @prev_extension 
+			out
+		end
+
+		alias_method :orig_prepare!, :prepare!
+		def prepare! *args
+			@prev_extension = @view.current_render_extension
+			orig_prepare! *args
+		end
+	end
+else
+	class ActionView::Template
+		alias_method :orig_render, :render
+		def render *args
+			out = orig_render *args
+			@view.current_render_extension = @prev_extension
+			out
+		end
+
+		alias_method :orig_prepare!, :prepare!
+		def prepare! *args
+			@prev_extension = @view.current_render_extension
+			orig_prepare! *args
+		end
+	end
+	class ActionView::PartialTemplate
+		alias_method :orig_render, :render
+		def render *args
+			out = orig_render *args
+			@view.current_render_extension = @prev_extension
+			out
+		end
+	end
+end
+
+ActionView::Template.register_template_handler 'mn', Malline::RailsHandler

data/lib/malline/erb_out.rb

@@ -16,11 +16,16 @@
 # along with Malline.  If not, see <http://www.gnu.org/licenses/>.
 
 module Malline
-	# ERB emulator
+	# Since some parts of Rails use ERB directly instead of current template
+	# handler, we have to capture all that data.
+	#
+	# In practice the erb buffer object (named ActiveView::Base.erb_variable)
+	# is a string, where data is simply concatted.
 	class ErbOut
 		def initialize view
 			@view = view
 		end
+		# Redirect all data to view
 		def concat value
 			@view << value
 		end

data/lib/malline/form_builder.rb

@@ -16,14 +16,25 @@
 # along with Malline.  If not, see <http://www.gnu.org/licenses/>.
 
 module Malline
+	# Capture form elements directly from FormBuilder, so that there is no
+	# need to specially render any elements.
+	# In other words, with our own FormBuilder-wrapper we can do this:
+	# 	form_for :comment, Comment.new, :url => edit_url do |f|
+	# 		f.text_field :name
+	# 	end
+	# instead of
+	# 	..
+	# 	self << f.text_field(:name)
 	class FormBuilder
-		def initialize *args
+		# Wrap the Rails FormBuilder in @builder
+		def initialize *args, &block
 			@view = eval('self', args.last)
-			@view = nil unless @view.respond_to?(:is_malline?) && @view.is_malline?
-			@builder = ::ActionView::Helpers::FormBuilder.new(*args)
+			@builder = ::ActionView::Helpers::FormBuilder.new(*args, &block)
 		end
+		# Render every f.foo -method to view, unless we aren't using
+		# Malline template now
 		def method_missing *args, &block
-			if @view
+			if @view && @view.is_malline?
 				@view << @builder.send(*args, &block)
 			else
 				@builder.send(*args, &block)

data/lib/malline/plugin.rb

@@ -0,0 +1,34 @@
+# Copyright © 2007,2008 Riku Palomäki
+#
+# This file is part of Malline.
+#
+# Malline is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Malline is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Malline.  If not, see <http://www.gnu.org/licenses/>.
+
+# Malline very incomplete Plugin interface.
+class Malline::Plugin
+	# Install a new plugin: Malline::WhatEverPlugin.install view
+	def self.install view
+		return if view.malline.plugins.include? self
+		self.do_install view
+		view.malline.plugins << self
+	end
+
+	protected
+	def self.do_install view
+		raise NotImplementedError.new
+	end
+	def self.do_uninstall view
+		raise NotImplementedError.new("#{self} cannot be uninstalled")
+	end
+end

data/lib/malline/{view_xhtml.rb → plugins/xhtml.rb}

@@ -15,7 +15,13 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with Malline.  If not, see <http://www.gnu.org/licenses/>.
 
-module Malline::XHTML
+# Quite stupid plugin for XHTML, we should be able to do this only with a DTD
+# or similar.
+#
+# Defines all usable tags, list which one can be self-close, defines a short
+# cut tag *xhtml*. Also makes sure that there is some necessary elements in
+# the document.
+class Malline::XHTML < Malline::Plugin
 	CUSTOM_TAGS = %w{head title meta}
 
 	# grep ELEMENT xhtml1-transitional.dtd | cut -d' ' -f2 | tr "\n" " "
@@ -63,9 +69,9 @@ module Malline::XHTML
 		end
 	end
 
-	def self.load_plugin base
-		base.definetags *XHTML_TAGS
-		base.view.malline.short_tag_excludes += SHORT_TAG_EXCLUDES
-		base.view.extend Tags
+	def self.do_install view
+		view.malline.definetags! XHTML_TAGS
+		view.malline.short_tag_excludes += SHORT_TAG_EXCLUDES
+		view.extend Tags
 	end
 end

data/lib/malline/rails.rb

@@ -16,30 +16,31 @@
 # along with Malline.  If not, see <http://www.gnu.org/licenses/>.
 
 require 'malline' unless Kernel.const_defined?('Malline')
+require 'malline/form_builder.rb'
 
-ActionView::Base.register_template_handler 'mn', Malline::Base
+if Rails::VERSION::STRING <= "2.0.z"
+	require 'malline/adapters/rails-2.0'
+else
+	require 'malline/adapters/rails-2.1'
+end
 
-module ActionView
-	class Base
-		alias_method :orig_render_template, :render_template
-		def render_template template_extension, template, file_path = nil, *rest
-			@current_tpl_path = file_path
-			orig_render_template(template_extension, template, file_path, *rest)
-		end
+# Activate our FormBuilder wrapper, so we can use forms more easily
+ActionView::Base.default_form_builder = Malline::FormBuilder
+
+module Malline::ViewWrapper
+	@@malline_methods << 'cache'
 
-		alias_method :orig_delegate_render, :delegate_render
-		def delegate_render(handler, template, local_assigns)
-			old = @malline_is_active
-			tmp = if handler == Malline::Base
-				h = handler.new(self)
-				h.set_path(@current_tpl_path) if @current_tpl_path
-				h.render(template, local_assigns)
-			else
-				@malline_is_active = false
-				orig_delegate_render(handler, template, local_assigns)
-			end
-			@malline_is_active = old
-			tmp
+	# Rails caching
+	def _malline_cache name = {}, options = {}, &block
+		return block.call unless @controller.perform_caching
+		cache = @controller.read_fragment(name, options)
+
+		unless cache
+			cache = _malline_capture { block.call }
+			@controller.write_fragment(name, cache, options)
 		end
+		@malline.add_unescaped_text cache
 	end
 end
+
+

data/lib/malline/template.rb

@@ -16,11 +16,26 @@
 # along with Malline.  If not, see <http://www.gnu.org/licenses/>.
 
 module Malline
+	# This is the class that really evaluates the template and is accessible
+	# from the view by "malline", for example:
+	# 	malline.path = 'File name'
 	class Template
+		# Current options (like @@options in Base)
 		attr_accessor :options
+		# List of every tag that doesn't support self-closing syntax
 		attr_accessor :short_tag_excludes
+		# Current state of :whitespace-modifier (bool)
 		attr_accessor :whitespace
+		# Current file name
 		attr_accessor :path
+		# Every overriden (in definetags!) helper method (:name => method)
+		attr_accessor :helper_overrides
+		# Every available tag, excluding the specific methods (:name => bool)
+		attr_accessor :tags
+		# Render result of the last #render
+		attr_reader :rendered
+		# List all installed plugins
+		attr_accessor :plugins
 
 		def initialize view, opts
 			@view = view
@@ -28,13 +43,25 @@ module Malline
 			@path = 'Malline template'
 			@options = opts
 			@short_tag_excludes = []
+			@helper_overrides = {}
+			@tags = {}
+			@plugins = []
+			@inited = false
 		end
 
-		# These two are stolen from ERB
-		# © 1999-2000,2002,2003 Masatoshi SEKI
+		# Install plugins and do every thing that cannot be done in initialize
+		# Plugin install will use @view.malline, that will create a duplicate
+		# Template instance, if it's called from initialize.
+		def init
+			return if @inited
+			XHTML.install @view if @options[:xhtml]
+		end
+
+		# Stolen from ERB, © 1999-2000,2002,2003 Masatoshi SEKI
 		def self.html_escape(s)
 			s.to_s.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
 		end
+		# Stolen from ERB, © 1999-2000,2002,2003 Masatoshi SEKI
 		def self.url_encode(s)
 			s.to_s.gsub(/[^a-zA-Z0-9_\-.]/n){ sprintf("%%%02X", $&.unpack("C")[0]) }
 		end
@@ -51,23 +78,33 @@ module Malline
 			@dom = tmp
 		end
 
+		# Add escaped string to @dom
 		def add_text *values
 			@dom << ' ' if @whitespace
 			@dom << Template.html_escape(values.join(' '))
 		end
 
+		# Add unescaped string to @dom
 		def add_unescaped_text value
 			@dom << ' ' if @whitespace
 			@dom << value.to_s unless value.nil?
 		end
 
+		# Call a helper (a method defined outside malline whose
+		# output is stored to @dom)
 		def helper helper, *args, &block
-			tmp = @view.send(helper, *args, &block)
+			helper = helper.to_sym
+			tmp = if h = @helper_overrides[helper]
+				h.call *args, &block
+			else
+				@view.send helper, *args, &block
+			end
 			@dom << ' ' if @whitespace
 			@dom << tmp.to_s
 			tmp
 		end
 
+		# Add a tag to @dom
 		def tag s, *args, &block
 			tag = { :name => s.to_s, :attrs => {}, :children => [] }
 
@@ -89,15 +126,15 @@ module Malline
 			ViewProxy.new self, tag
 		end
 
-		# Render the xml tree at dom or root
+		# Render the XML tree at dom or @dom
 		def render dom = nil
-			(dom || @dom).inject('') do |out, tag|
+			@rendered = (dom || @dom).inject('') do |out, tag|
 				if tag.is_a?(String)
 					out << tag
 				else
 					out << ' ' if tag[:whitespace]
 					out << "<#{tag[:name]}"
-					out << tag[:attrs].inject(''){|s, a| s += " #{a.first}=\"#{Template.html_escape(a.last)}\""}
+					out << tag[:attrs].inject(''){|s, a| s + " #{a.first}=\"#{Template.html_escape(a.last)}\""}
 
 					if tag[:children].empty?
 						if @short_tag_excludes.include?(tag[:name])
@@ -116,9 +153,33 @@ module Malline
 
 		# Execute and render a text or block
 		def run tpl = nil, &block
+			init
 			tmp = []
 			execute tmp, tpl, &block
 			render tmp
 		end
+
+		# Define tags as a methods, overriding all same named methods
+		def definetags! *tags
+			tags.flatten.each do |tag|
+				tag = tag.to_sym
+				@helper_overrides[tag] = @view.method(tag) if @view.respond_to?(tag)
+				define_tag! tag
+			end
+		end
+
+		# Marking tags as usable, but not overriding anything
+		def definetags *tags
+			tags.flatten.each{|tag| @tags[tag] = true }
+		end
+
+		# Define a method tag
+		def define_tag! tag
+			eval %{
+				def @view.#{tag}(*args, &block)
+					tag!('#{tag}', *args, &block)
+				end
+			}
+		end
 	end
 end

data/lib/malline/view_proxy.rb

@@ -16,39 +16,72 @@
 # along with Malline.  If not, see <http://www.gnu.org/licenses/>.
 
 module Malline
+	# Every tag returns a ViewProxy object that binds the tag to the template.
+	# ViewProxy also chains the process by returning itself.
+	#
+	# This Proxy object then makes possible the attribute syntax:
+	# 	div.foo.bar! { stuff }
+	#
+	# div returns new ViewProxy instance, so div.foo actually calls
+	# ViewProxy#foo, which is then generated to class="foo" -attribute to the
+	# original tag div. div.foo returns the same ViewProxy, and foo.bar! calls
+	# ViewProxy#bar!, which is interpreted as a id="bar" -attribute.
+	#
+	# Finally the given block { stuff } is evaluated the same way than it would
+	# be evaluated without the ViewProxy:
+	#   div { stuff }
 	class ViewProxy
 		def initialize template, tag
 			@tpl = template
 			@tag = tag
 		end
 
-		def __yld &block
-			@tpl.execute @tag[:children], &block
-		end
-
-		def method_missing(s, *args, &block)
+		# Allows to add new content to already closed tag, for example:
+		# 	t = div do
+		# 		_'text'
+		# 	end
+		# 	t.__yld :whitespace { stuff }
+		#
+		# Intended for internal use only
+		def __yld *args, &block
+			# div :title => 'data'
 			if args.last.is_a?(Hash)
 				@tag[:attrs].merge!(args.pop)
 			end
 
-			if /\!$/ =~ s.to_s
-				@tag[:attrs]['id'] = s.to_s.chomp('!')
-			else
-				if @tag[:attrs]['class']
-					@tag[:attrs]['class'] << " #{s}"
-				else
-					@tag[:attrs]['class'] = s.to_s
-				end
-			end
-
+			# Modifiers
 			whitespace = @tpl.whitespace
 			@tpl.whitespace = true if args.delete(:whitespace)
-			txt = args.flatten.join('')
+
+			# Rest is just content separated by a space
+			txt = args.flatten.join ' '
 			@tag[:children] << txt unless txt.empty?
 
+			# Block
 			@tpl.execute @tag[:children], &block if block_given?
+
+			# Restore modifiers
 			@tpl.whitespace = whitespace
+
+			# Chain the calls, for example: div.foo.bar!.yeah.boring
 			self
 		end
+
+		# Capture attribute definitions, special modifiers and blocks
+		def method_missing s, *args, &block
+			# div.id!
+			if /^(.*)!$/ =~ s.to_s
+				@tag[:attrs]['id'] = $1
+			elsif s
+				# div.class
+				if @tag[:attrs]['class']
+					@tag[:attrs]['class'] << " #{s}"
+				else
+					@tag[:attrs]['class'] = s.to_s
+				end
+			end
+
+			__yld *args, &block
+		end
 	end
 end

data/lib/malline/view_wrapper.rb

@@ -16,13 +16,14 @@
 # along with Malline.  If not, see <http://www.gnu.org/licenses/>.
 
 module Malline
+	# ViewWrapper is extended into used view object, like ActiveView::Base.
+	# Every method in ViewWrapper will pollute the original namespace.
 	module ViewWrapper
-		attr_accessor :malline_is_active
-
 		# List of all methods that may override some custom view methods
 		# If is_malline?, then their _malline_ -prefix versions are called
-		@@malline_methods = %w{_erbout cache capture _ tag! << txt!}
+		@@malline_methods = %w{_erbout capture _ tag! << txt!}
 
+		# Initialize @@malline_methods
 		def init_malline_methods
 			@malline_methods_inited = true
 			@@malline_methods.each do |m|
@@ -31,61 +32,64 @@ module Malline
 			end
 		end
 
+		# Returns a current Template instance, makes a new if called first time
+		# Can also be used to set options to Template by giving them as hash opts:
+		# 	malline :whitespace => true
 		def malline opts = nil
 			if @malline
 				@malline.options.merge!(opts) if opts.is_a?(Hash)
 			else
-				@malline = Template.new(self, opts)
+				@malline = Template.new(self, opts || {})
 			end
 			init_malline_methods unless @malline_methods_inited
 			@malline
 		end
 		
+		# erbout emulator
 		def _malline__erbout
 			@_erbout ||= ErbOut.new(self)
 		end
 
-		def _malline_cache name = {}, options = {}, &block
-			return block.call unless @controller.perform_caching
-			cache = @controller.read_fragment(name, options)
-
-			unless cache
-				cache = _malline_capture { block.call }
-				@controller.write_fragment(name, cache, options)
-			end
-			@malline.add_unescaped_text cache
-		end
-
+		# capture and return the output of the block
 		def _malline_capture &block
 			@malline.run &block
 		end
 
+		# _'escaped text'
 		def _malline__ *args
 			@malline.add_text(*args)
 		end
 		alias_method :_malline_txt!, :_malline__
 
+		# self << "<unescaped text>"
 		def _malline_ltlt *args
 			@malline.add_unescaped_text *args
 		end
 
+		# Define a new tag of call a helper (if _prefixed)
 		def method_missing s, *args, &block
 			return super unless is_malline?
-			helper = (s.to_s[0].chr == '_') ? s.to_s[1..255].to_sym : s.to_sym
-			if respond_to?(helper)
-				@malline.helper(helper, *args, &block)
+			if @malline.tags[s]
+				@malline.tag s, *args, &block
 			else
-				return super if @malline.options[:strict]
-				_malline_tag! s, *args, &block
+				helper = ((s.to_s[0] == ?_) ? s.to_s[1..-1] : s).to_sym
+				if respond_to?(helper)
+					@malline.helper(helper, *args, &block)
+				else
+					return super if @malline.options[:strict]
+					_malline_tag! s, *args, &block
+				end
 			end
 		end
 
+		# Define a new tag
 		def _malline_tag! *args, &block
 			@malline.tag *args, &block
 		end
 
+		# Are we in a Malline template
 		def is_malline?
-			@malline_is_active
+			true
 		end
 	end
 end

data/test/malline_test.rb

@@ -19,35 +19,6 @@ $: << t
 $: << File.join(t, 'lib')
 require 'test/unit'
 require 'test/malline_test_helpers.rb'
-require 'malline.rb'
-
-class Controller
-	def perform_caching
-		false
-	end
-end
-
-class Comment
-end
-
-class View
-	def initialize
-		@controller = Controller.new
-	end
-	def image_path(im)
-		"/images/#{im.is_a?(MallineTestHelpers::Image) ? im.id : 'img'}"
-	end
-	def truncate(str, size = 10)
-		str[0...size]
-	end
-	def render hash
-		Malline::Base.new(View.new).render File.read(File.join(File.dirname(__FILE__), hash[:partial].sub(/\//, '/_') + '.mn')) rescue ''
-	end
-	def link_to *args
-		'link'
-	end
-end
-
 
 class MallineTest < Test::Unit::TestCase
 	include Malline
@@ -55,10 +26,11 @@ class MallineTest < Test::Unit::TestCase
 
 	def test_simple
 		Base.setopt :strict => false, :xhtml => false do
-			assert_xml_equal('<foo id="a"><bar class="a b"/></foo>',
+			assert_xml_equal('<foo id="a"><bar class="a b"/>blabla</foo>',
 				Base.render do
 					foo.a! do
 						bar.a.b
+						_'blabla'
 					end
 				end
 			)
@@ -109,22 +81,29 @@ class MallineTest < Test::Unit::TestCase
 		end
 		b = Proc.new do
 			foo do
-				xxx :a => 'b' do
+				zoo :a => 'b' do
 					bar
 				end
+				_zoo
+				xoo.bar
 			end
 		end
 		out = tpl.render nil, &b
-		assert_xml_equal('<foo/>', out)
+		# zoo isn't rendered, because there is helper named zoo
+		assert_xml_equal('<foo>zoo output<xoo class="bar"/></foo>', out)
+
+		tpl.definetags :zoo
+		out = tpl.render nil, &b
+		assert_xml_equal('<foo>zoo output<xoo class="bar"/></foo>', out)
 
-		tpl.definetags :xxx
+		tpl.definetags! :zoo
 		out = tpl.render nil, &b
-		assert_xml_equal('<foo><xxx a="b"><bar/></xxx></foo>', out)
+		assert_xml_equal('<foo><zoo a="b"><bar/></zoo>zoo output<xoo class="bar"/></foo>', out)
 
 		out = Base.setopt :strict => false, :xhtml => false do
 			Base.render &b
 		end
-		assert_xml_equal('<foo/>', out)
+		assert_xml_equal('<foo><zoo a="b"><bar/></zoo><_zoo/><xoo class="bar"/></foo>', out)
 	end
 
 	def test_xhtml

data/test/malline_test_helpers.rb

@@ -16,11 +16,7 @@
 # along with Malline.  If not, see <http://www.gnu.org/licenses/>.
 
 require "rexml/document"
-
-module Kernel
-	def xxx *args
-	end
-end
+require 'malline.rb'
 
 module MallineTestHelpers
 	include REXML
@@ -55,3 +51,32 @@ module MallineTestHelpers
 	end
 end
 
+class Controller
+	def perform_caching
+		false
+	end
+end
+
+class Comment
+end
+
+class View
+	def initialize
+		@controller = Controller.new
+	end
+	def image_path(im)
+		"/images/#{im.is_a?(MallineTestHelpers::Image) ? im.id : 'img'}"
+	end
+	def truncate(str, size = 10)
+		str[0...size]
+	end
+	def render hash
+		Malline::Base.new(View.new).render File.read(File.join(File.dirname(__FILE__), hash[:partial].sub(/\//, '/_') + '.mn')) rescue ''
+	end
+	def link_to *args
+		'link'
+	end
+	def zoo *args
+		'zoo output'
+	end
+end

metadata

@@ -1,110 +1,118 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: malline
 version: !ruby/object:Gem::Version 
-  version: 1.0.2
-date: 2008-04-01 00:00:00 +03:00
-summary: Malline is a full-featured pure Ruby template system designed to be a replacement for ERB views in Rails or any other framework. See http://www.malline.org/ for more info.
-require_paths: 
-- lib
-email: riku@palomaki.fi
-homepage: http://www.malline.org/
-rubyforge_project: malline
-description: Malline is a full-featured template system designed to be a replacement for ERB views in Rails or any other framework. It also includes standalone bin/malline to compile Malline templates to XML in commandline. All Malline templates are pure Ruby, see http://www.malline.org/ for more info.
-autorequire: malline
-default_executable: 
-bindir: bin
-has_rdoc: false
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 1.1.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - "Riku Palom\xC3\xA4ki"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-06 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: Malline is a full-featured template system designed to be a replacement for ERB views in Rails or any other framework. It also includes standalone bin/malline to compile Malline templates to XML in commandline. All Malline templates are pure Ruby, see http://www.malline.org/ for more info.
+email: riku@palomaki.fi
+executables: 
+- malline
+extensions: []
+
+extra_rdoc_files: 
+- README
 files: 
 - lib/malline.rb
 - lib/malline/erb_out.rb
-- lib/malline/view_xhtml.rb
-- lib/malline/form_builder.rb
-- lib/malline/view_wrapper.rb
-- lib/malline/template.rb
 - lib/malline/view_proxy.rb
 - lib/malline/rails.rb
+- lib/malline/view_wrapper.rb
+- lib/malline/form_builder.rb
+- lib/malline/adapters/rails-2.1.rb
+- lib/malline/adapters/rails-2.0.rb
+- lib/malline/template.rb
+- lib/malline/plugin.rb
+- lib/malline/plugins/xhtml.rb
 - bin/malline
 - COPYING.LESSER
 - COPYING
 - README
 - scripts/html2mn.rb
+- test/malline_test_helpers.rb
 - test/examples
 - test/kernel.org.mn
-- test/malline_test.rb
-- test/malline_test_helpers.rb
 - test/kernel.org.html
-- test/examples/_partial.target
-- test/examples/options.target
+- test/malline_test.rb
 - test/examples/_two.mn
+- test/examples/options.mn
+- test/examples/whitespace.mn
+- test/examples/id.mn
+- test/examples/helper2.mn
+- test/examples/_partial.mn
+- test/examples/helper2.target
+- test/examples/text.target
+- test/examples/escape.target
+- test/examples/_two.target
+- test/examples/class.mn
+- test/examples/_partial.target
+- test/examples/nested.mn
 - test/examples/xhtml.target
-- test/examples/hello_world.mn
+- test/examples/capture.target
+- test/examples/partials.target
+- test/examples/_action.mn
+- test/examples/self.mn
+- test/examples/_three.rhtml
+- test/examples/helper.target
 - test/examples/lists.target
-- test/examples/layout.mn
+- test/examples/_action.target
+- test/examples/layout.target
+- test/examples/hello_world.target
+- test/examples/id.target
 - test/examples/helper.mn
-- test/examples/_one.mn
 - test/examples/class.target
-- test/examples/nested.mn
-- test/examples/text.mn
-- test/examples/frontpage.mn
-- test/examples/helper_shortcut.target
-- test/examples/_action.target
-- test/examples/_partial.mn
-- test/examples/options.mn
-- test/examples/partials.target
+- test/examples/capture.mn
+- test/examples/layout.mn
+- test/examples/escape.mn
+- test/examples/frontpage.target
+- test/examples/partials.mn
+- test/examples/_one.target
+- test/examples/hello_world.mn
 - test/examples/xhtml.mn
 - test/examples/lists.mn
-- test/examples/fragment_cache.target
-- test/examples/class.mn
-- test/examples/self.target
-- test/examples/id.target
+- test/examples/_one.mn
+- test/examples/nested.target
+- test/examples/options.target
 - test/examples/whitespace.target
+- test/examples/self.target
+- test/examples/helper_shortcut.target
+- test/examples/text.mn
 - test/examples/helper_shortcut.mn
-- test/examples/_action.mn
-- test/examples/escape.target
-- test/examples/helper2.target
-- test/examples/capture.target
-- test/examples/partials.mn
-- test/examples/_three.rhtml
-- test/examples/_two.target
-- test/examples/hello_world.target
-- test/examples/fragment_cache.mn
-- test/examples/layout.target
-- test/examples/self.mn
-- test/examples/helper.target
-- test/examples/id.mn
-- test/examples/_one.target
-- test/examples/whitespace.mn
-- test/examples/nested.target
-- test/examples/escape.mn
-- test/examples/text.target
-- test/examples/helper2.mn
-- test/examples/frontpage.target
-- test/examples/capture.mn
-test_files: 
-- test/malline_test.rb
+- test/examples/frontpage.mn
+has_rdoc: true
+homepage: http://www.malline.org/
+post_install_message: 
 rdoc_options: []
 
-extra_rdoc_files: 
-- README
-executables: 
-- malline
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
-
+rubyforge_project: malline
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: Malline is a full-featured pure Ruby template system designed to be a replacement for ERB views in Rails or any other framework. See http://www.malline.org/ for more info.
+test_files: 
+- test/malline_test.rb

data/test/examples/fragment_cache.mn

@@ -1,10 +0,0 @@
-div do
-	cache "stuff" do
-		# This block is evaluated only if no cache with keyword stuff is found
-		# After evaluation the block is saved to cache
-		# If caching is not enabled, the cache block is transparent
-		h4 'Some partial stuff'
-		_render :partial => 'examples/partial'
-	end
-	_'dynamic content'
-end

data/test/examples/fragment_cache.target

@@ -1 +0,0 @@
-<div><h4>Some partial stuff</h4><div>I always thought something was fundamentally wrong with the universe.</div>dynamic content</div>