dryml 1.1.0 → 1.3.0.RC

data/lib/dryml/template_environment.rb

@@ -1,7 +1,7 @@
 module Dryml
 
   class TemplateEnvironment
-    
+
     class << self
       def inherited(subclass)
         subclass.compiled_local_names = []
@@ -26,10 +26,9 @@ module Dryml
     include ActionView::Helpers
     include Helper  ## FIXME remove
 
-    def initialize(view_name=nil, view=nil)
-      unless view_name.nil? && view.nil?
+    def initialize(view=nil)
+      unless view.nil?
         @view = view
-        @_view_name = view_name
         @_erb_binding = binding
         @_part_contexts = {}
         @_scoped_variables = ScopedVariables.new
@@ -49,14 +48,14 @@ module Dryml
       end
     end
 
-    for attr in [:erb_binding, :part_contexts, :view_name,
+    for attr in [:erb_binding, :part_contexts,
                  :this, :this_parent, :this_field, :this_key,
                  :form_this, :form_field_path, :form_field_names]
       class_eval "def #{attr}; @_#{attr}; end"
     end
-    
+
     def path_for_form_field
-      @_form_field_path.nil? and raise Dryml::DrymlException, 
+      @_form_field_path.nil? and raise Dryml::DrymlException,
         "DRYML cannot provide the correct form-field name here (this_field = #{this_field.inspect}, this = #{this.inspect})"
       @_form_field_path
     end
@@ -142,10 +141,10 @@ module Dryml
           object = this
         end
       end
-      
+
       id = if (typed_id = object.try.typed_id)
              typed_id
-           elsif object == @this
+           elsif object == this
              "this"
            end
       attribute ? "#{id}:#{attribute}" : id
@@ -160,26 +159,26 @@ module Dryml
       end
       res
     end
-    
-    
+
+
     def refresh_part(encoded_context, session, dom_id)
-      context = Dryml::PartContext.for_refresh(encoded_context, @this, session)
-        
+      context = Dryml::PartContext.for_refresh(encoded_context, this, session)
+
       with_part_context(context) do
         send("#{context.part_name}_part", *context.locals)
       end
     end
 
-    
+
     def with_part_context(context, &block)
       this, this_field = context.this, context.this_field
-      
+
       b = if context.form_field_path
             proc { with_form_context(:unknown, context.form_field_path, &block) }
           else
             block
           end
-      
+
       if this && this_field
         new_object_context(this) { new_field_context(this_field, &b) }
       elsif this
@@ -206,11 +205,13 @@ module Dryml
 
     def find_polymorphic_tag(name, call_type=nil)
       call_type ||= (this.respond_to?(:member_class) && this.member_class) || this_type
-      
       begin
         found = nil
         while true
-          if respond_to?(poly_name = "#{name}__for_#{call_type.name.to_s.underscore.gsub('/', '__')}")
+          # ActiveSupport::TimeWithZone.name would return 'Time'
+          # so we add an exception to pick the right datetime type
+          type_name = ( call_type == ActiveSupport::TimeWithZone ? 'datetime' : call_type.name.to_s).underscore.gsub('/', '__')
+          if respond_to?(poly_name = "#{name}__for_#{type_name}")
             found = poly_name
             break
           else
@@ -236,7 +237,7 @@ module Dryml
       else
         res = context_map(string_or_array) { yield }
       end
-      res.join
+      res.safe_join
     end
 
 
@@ -283,17 +284,17 @@ module Dryml
           parent, field, obj = Dryml.get_field_path(this, path)
           @_this, @_this_parent, @_this_field = obj, parent, field
         end
-        
+
         if @_form_field_path
-          @_form_field_path += path 
+          @_form_field_path += path
           @_form_field_paths_by_object[@_this] = @_form_field_path
         end
-        
+
         yield
       end
     end
-    
-    
+
+
     def find_form_field_path(object)
       back = []
       while object
@@ -310,8 +311,8 @@ module Dryml
         end
       end
     end
-        
-        
+
+
 
 
     def _tag_context(attributes)
@@ -331,13 +332,14 @@ module Dryml
 
 
     def with_form_context(form_this=this, form_field_path=[form_this.class.name.underscore])
+      ctx = [@_form_this, @_form_field_path, @_form_field_paths_by_object]
       @_form_this = form_this
       @_form_field_path = form_field_path
       @_form_field_paths_by_object = { form_this => form_field_path }
       res = scope.new_scope :in_form => true, :form_field_names => [] do
         yield
       end
-      @_form_this = @_form_field_path = @_form_field_paths_by_object = nil
+      @_form_this, @_form_field_path, @_form_field_paths_by_object = ctx
       res
     end
 
@@ -348,7 +350,7 @@ module Dryml
 
 
     def _tag_locals(attributes, locals)
-      attributes.symbolize_keys!
+      attributes = attributes.symbolize_keys
       #ensure with and field are not in attributes
       attributes.delete(:with)
       attributes.delete(:field)
@@ -386,13 +388,13 @@ module Dryml
     def call_tag_parameter(the_tag, attributes, parameters, caller_parameters, param_name)
       overriding_proc = caller_parameters[param_name]
       replacing_proc  = caller_parameters[:"#{param_name}_replacement"]
-      
+
       unless param_name == the_tag || param_name == :default
         classes = attributes[:class]
         param_class = param_name.to_s.gsub('_', '-')
         attributes[:class] = if classes
                                classes =~ /\b#{param_class}\b/ ? classes : "#{classes} #{param_class}"
-                             else 
+                             else
                                param_class
                              end
       end
@@ -456,7 +458,7 @@ module Dryml
               else
                 proc { |default| default_content.call(default) if default_content }
               end
-          parameters = parameters.merge(:default => d) 
+          parameters = parameters.merge(:default => d)
         end
 
         if the_tag.is_one_of?(String, Symbol)
@@ -511,25 +513,17 @@ module Dryml
         end
       end
     end
-    
-    
+
+
     def merge_parameter_hashes(given_parameters, overriding_parameters)
       to_merge = given_parameters.keys & overriding_parameters.keys
       no_merge = overriding_parameters.keys - to_merge
       result = given_parameters.dup
-      
+
       no_merge.each { |k| result[k] = overriding_parameters[k] }
       to_merge.each { |k| result[k] = merge_tag_parameter(given_parameters[k], overriding_parameters[k])}
-      
-      result
-    end
-      
-      
 
-
-    def part_contexts_javascripts
-      storage = part_contexts_storage
-      storage.blank? ? "" : "<script type=\"text/javascript\">\n#{storage}</script>\n"
+      result
     end
 
 
@@ -541,14 +535,7 @@ module Dryml
     def render_tag(tag_name, attributes)
       method_name = tag_name.to_s.gsub('-', '_')
       if respond_to?(method_name)
-        res = send(method_name, attributes).strip
-
-        # TODO: Temporary hack to get the dryml metadata comments in the right place
-        if false && RAILS_ENV == "development"
-          res.gsub(/^(.*?)(<!DOCTYPE.*?>).*?(<html.*?>)/m, "\\2\\3\\1")
-        else
-          res
-        end
+        send(method_name, attributes).strip
       else
         false
       end
@@ -580,14 +567,13 @@ module Dryml
         end
         attr_string = " #{attrs.sort * ' '}" unless attrs.empty?
       end
-
-      content = new_context { yield } if block_given?
+      content = capture { new_context &block } if block_given?
       res = if empty
-              "<#{name}#{attr_string}#{scope.xmldoctype ? ' /' : ''}>"
+              "<#{name}#{attr_string}#{scope.xmldoctype ? ' /' : ''}>".html_safe
             else
-              "<#{name}#{attr_string}>#{content}</#{name}>"
+              "<#{name}#{attr_string}>".html_safe + content + "</#{name}>".html_safe
             end
-      if block_called_from_erb? block
+      if content.is_a? ActionView::NonConcattingString
         concat res
       else
         res

data/lib/dryml.rb

@@ -4,294 +4,232 @@
 # Copyright:: Copyright (c) 2008
 # License::   Distributes under the same terms as Ruby
 
-
-
-# gem dependencies
-require 'hobosupport'
+require 'hobo_support'
 require 'action_pack'
-require 'active_record' if ActionPack::VERSION::MAJOR==2 && ActionPack::VERSION::MINOR==2
-
-if ActiveSupport.const_defined? :Dependencies
-  if ActiveSupport::Dependencies.respond_to?(:autoload_paths)
-    ActiveSupport::Dependencies.autoload_paths |= [ File.dirname(__FILE__)]
-  else
-    ActiveSupport::Dependencies.load_paths |= [ File.dirname(__FILE__)]
-  end
-end
 
-# Hobo can be installed in /vendor/hobo, /vendor/plugins/hobo, vendor/plugins/hobo/hobo, etc.
-::DRYML_ROOT = File.expand_path(File.dirname(__FILE__) + "/..")
+ActiveSupport::Dependencies.autoload_paths |= [File.dirname(__FILE__)]
 
 # The Don't Repeat Yourself Markup Language
 module Dryml
 
-    VERSION = "1.1.0"
-
-    class DrymlSyntaxError < RuntimeError; end
-      
-    class DrymlException < Exception
-      def initialize(message, path=nil, line_num=nil)
-        if path && line_num
-          super(message + " -- at #{path}:#{line_num}")
-        else
-          super(message)
-        end
-      end
-    end
-
-    TagDef = Struct.new "TagDef", :name, :attrs, :proc
+  VERSION = File.read(File.expand_path('../../VERSION', __FILE__)).strip
+  @@root = Pathname.new File.expand_path('../..', __FILE__)
+  def self.root; @@root; end
 
-    RESERVED_WORDS = %w{if for while do class else elsif unless case when module in}
+  class DrymlSyntaxError < RuntimeError; end
 
-    EMPTY_PAGE = "[tag-page]"
-
-    APPLICATION_TAGLIB = { :src => "taglibs/application" }
-    CORE_TAGLIB        = { :src => "core", :plugin => "dryml" }
-
-    DEFAULT_IMPORTS = defined?(ApplicationHelper) ? [ApplicationHelper] : []
-
-    @renderer_classes = {}
-    @tag_page_renderer_classes = {}
-
-    extend self
-
-    attr_accessor :last_if
-    
-    def enable(generator_directories=[], output_directory=".")
-      ActionView::Template.register_template_handler("dryml", Dryml::TemplateHandler)
-      if ActionView::Template.respond_to? :exempt_from_layout
-        ActionView::Template.exempt_from_layout('dryml')
-      elsif
-        ActionView::Base.exempt_from_layout('dryml')
-      end
-      DrymlGenerator.enable(generator_directories, output_directory)
-    end
-    
-    
-    def precompile_taglibs
-      Dir.chdir(RAILS_ROOT) do
-        taglibs = Dir["vendor/plugins/**/taglibs/**/*.dryml"] + Dir["app/views/taglibs/**/*.dryml"]
-        taglibs.each do |f|
-          Dryml::Taglib.get(:template_dir => File.dirname(f), :src => File.basename(f).remove(".dryml"))
-        end
+  class DrymlException < Exception
+    def initialize(message, path=nil, line_num=nil)
+      if path && line_num
+        super(message + " -- at #{path}:#{line_num}")
+      else
+        super(message)
       end
     end
-    
-
-    def clear_cache
-      @renderer_classes = {}
-      @tag_page_renderer_classes = {}
-    end
-
-    def render_tag(view, tag, options={})
-      renderer = empty_page_renderer(view)
-      renderer.render_tag(tag, options)
-    end
-
-
-    def empty_page_renderer(view)
-      controller_name = view.controller.class.name.underscore.sub(/_controller$/, "")
-      page_renderer(view, [], "#{controller_name}/#{EMPTY_PAGE}")
-    end
-
-
-    def page_renderer_for_template(view, local_names, template)
-      page_renderer(view, local_names, template.path_without_extension, template.filename)
-    end
-
-
-    def page_renderer(view, local_names=[], page=nil, filename=nil)
-      if RAILS_ENV == "development"
-        clear_cache
-        Taglib.clear_cache
-      end
-
-      prepare_view!(view)
-      included_taglibs = ([APPLICATION_TAGLIB, subsite_taglib(page)] + controller_taglibs(view.controller.class)).compact
-
-      if page.ends_with?(EMPTY_PAGE)
-        # DELETE ME: controller_class = controller_class_for(page)
-        controller_class = view.controller.class
-        @tag_page_renderer_classes[controller_class.name] ||=
-          make_renderer_class("", page, local_names, DEFAULT_IMPORTS, included_taglibs)
-        @tag_page_renderer_classes[controller_class.name].new(page, view)
-      else        
-        filename ||= if view.view_paths.respond_to? :find_template
-                       # Rails 2.3
-                       view.view_paths.find_template(page + ".dryml").filename
-                     else
-                       # Rails 2.2
-                       view._pick_template(page + ".dryml").filename
-                     end
-        mtime = File.mtime(filename)
-        renderer_class = @renderer_classes[page]
+  end
 
-        # do we need to recompile?
-        if (!renderer_class ||                                          # nothing cached?
-            (local_names - renderer_class.compiled_local_names).any? || # any new local names?
-            renderer_class.load_time < mtime)                           # cache out of date?
-          renderer_class = make_renderer_class(File.read(filename), filename, local_names,
-                                               DEFAULT_IMPORTS, included_taglibs)
-          renderer_class.load_time = mtime
-          @renderer_classes[page] = renderer_class
-        end
-        renderer_class.new(page, view)
+  TagDef = Struct.new "TagDef", :name, :attrs, :proc
+  RESERVED_WORDS = %w{if for while do class else elsif unless case when module in}
+  ID_SEPARATOR = '; dryml-tag: '
+  APPLICATION_TAGLIB = { :src => "taglibs/application" }
+  CORE_TAGLIB        = { :src => "core", :plugin => "dryml" }
+  DEFAULT_IMPORTS = defined?(ApplicationHelper) ? [ApplicationHelper] : []
+  @cache = {}
+  extend self
+  attr_accessor :last_if
+
+  def precompile_taglibs
+    Dir.chdir(Rails.root) do
+      Dir["app/views/taglibs/**/*.dryml"].each do |f|
+        Taglib.get(:template_dir => File.dirname(f), :src => File.basename(f).remove(".dryml"))
       end
     end
+  end
 
+  def clear_cache
+    @cache = {}
+  end
 
-    # TODO: Delete this - not needed (use view.controller.class)
-    def controller_class_for(page)
-      controller, view = Controller.controller_and_view_for(page)
-      "#{controller.camelize}Controller".constantize
-    end
-
+  def render_tag(view, tag, options={})
+    renderer = empty_page_renderer(view)
+    renderer.render_tag(tag, options)
+  end
 
-    def controller_taglibs(controller_class)
-      controller_class.try.included_taglibs || []
-    end
+  def empty_page_renderer(view)
+    page_renderer(view, page_tag_identifier(view.controller.controller_path))
+  end
 
+  def page_tag_identifier(controller_path, tag_name='')
+    "controller: #{controller_path}#{ID_SEPARATOR}#{tag_name}"
+  end
 
-    def subsite_taglib(page)
-      parts = page.split("/")
-      subsite = parts.length >= 3 ? parts[0..-3].join('_') : "front"
-      src = "taglibs/#{subsite}_site"
-      { :src => src } if Object.const_defined?(:RAILS_ROOT) && File.exists?("#{RAILS_ROOT}/app/views/#{src}.dryml")
+  def call_render(view, local_assigns, identifier)
+    renderer = page_renderer(view, identifier, local_assigns.keys)
+    this = view.controller.send(:dryml_context) || local_assigns[:this]
+    view.instance_variable_set("@this", this)
+    if identifier =~ /#{ID_SEPARATOR}/
+      tag_name = identifier.split(ID_SEPARATOR).last
+      renderer.render_tag(tag_name, {:with => this} )
+    else
+      renderer.render_page(this, local_assigns).strip
     end
+  end
 
-    def get_field(object, field)
-      return nil if object.nil?
-      field_str = field.to_s
-      begin
-        return object.send(field_str)
-      rescue NoMethodError => ex
-        if field_str =~ /^\d+$/
-          return object[field.to_i]
-        else
-          return object[field]
-        end
+  def page_renderer(view, identifier, local_names=[], controller_path=nil)
+    controller_path ||= view.controller.controller_path
+    if identifier =~ /#{ID_SEPARATOR}/
+      identifier = identifier.split(ID_SEPARATOR).first
+      @cache[identifier] ||=  make_renderer_class("", "", local_names, taglibs_for(controller_path))
+      @cache[identifier].new(view)
+    else
+      mtime = File.mtime(identifier)
+      renderer_class = @cache[identifier]
+      # do we need to recompile?
+      if (!renderer_class ||                                          # nothing cached?
+          (local_names - renderer_class.compiled_local_names).any? || # any new local names?
+          renderer_class.load_time < mtime)                           # cache out of date?
+        renderer_class = make_renderer_class(File.read(identifier), identifier,
+                                             local_names, taglibs_for(controller_path))
+        renderer_class.load_time = mtime
+        @cache[identifier] = renderer_class
       end
+      renderer_class.new(view)
     end
+  end
 
-
-    def get_field_path(object, path)
-      path = if path.is_a? String
-               path.split('.')
-             else
-               Array(path)
-             end
-
-      parent = nil
-      path.each do |field|
-        return nil if object.nil?
-        parent = object
-        object = get_field(parent, field)
-      end
-      [parent, path.last, object]
-    end    
-
-
-    def prepare_view!(view)
-      # Not sure why this isn't done for me...
-      # There's probably a button to press round here somewhere
-      for var in %w(@flash @cookies @action_name @_session @_request @request_origin
-                    @template @request @ignore_missing_templates @_headers @variables_added
-                    @_flash @response @template_class
-                    @_cookies @before_filter_chain_aborted @url
-                    @_response @template_root @headers @_params @params @session)
-        unless @view.instance_variables.include?(var)
-          view.instance_variable_set(var, view.controller.instance_variable_get(var))
-        end
-      end
+  def get_field(object, field)
+    return nil if object.nil?
+    field_str = field.to_s
+    case
+    when object.respond_to?(field_str)
+      object.send(field_str)
+    when field_str =~ /^\d+$/
+      object[field.to_i]
+    else
+      object[field]
     end
+  end
 
-    # create and compile a renderer class (AKA Dryml::Template::Environment)
-    #
-    # template_src:: the DRYML source
-    # template_path:: the filename of the source.  This is used for
-    #                 caching
-    # locals:: local variables.
-    # imports:: A list of helper modules to import.  For example, Hobo
-    #           uses [Hobo::HoboHelper, Hobo::Translations,
-    #           ApplicationHelper] 
-    # included_taglibs:: A list of Taglibs to include. { :src =>
-    #                    "core", :plugin => "dryml" } is automatically
-    #                    added to this list.
-    #
-    def make_renderer_class(template_src, template_path, locals=[], imports=[], included_taglibs=[])
-      renderer_class = Class.new(TemplateEnvironment)
-      compile_renderer_class(renderer_class, template_src, template_path, locals, imports, included_taglibs)
-      renderer_class
+  def get_field_path(object, path)
+    return nil if object.nil?
+    path = path.is_a?(String) ? path.split('.') : Array(path)
+    parent = nil
+    path.each do |field|
+      parent = object
+      object = get_field(parent, field)
     end
+    [parent, path.last, object]
+  end
 
+  def unreserve(word)
+    word = word.to_s
+    word += '_' if RESERVED_WORDS.include?(word)
+    word
+  end
 
-    def compile_renderer_class(renderer_class, template_src, template_path, locals, imports, included_taglibs=[])
-      template = Dryml::Template.new(template_src, renderer_class, template_path)
-      imports.each {|m| template.import_module(m)}
+  def static_tags
+    @static_tags ||= begin
+                       path = if Object.const_defined?(:Rails) && FileTest.exists?("#{Rails.root}/config/dryml_static_tags.txt")
+                                  "#{Rails.root}/config/dryml_static_tags.txt"
+                              else
+                                  File.join(File.dirname(__FILE__), "dryml/static_tags")
+                              end
+                       File.readlines(path).*.chop
+                     end
+  end
 
-      taglibs = [CORE_TAGLIB] + included_taglibs
+  attr_writer :static_tags
+
+  # FIXME: This helper seems to be useless, since it does need Rails,
+  # and with Rails it is useless since Dryml does not need Hobo
+  #
+  # Helper function for use outside Hobo/Rails
+  #
+  # Pass the template context in locals[:this]
+  #
+  # This function caches.  If the mtime of template_path is older
+  # than the last compilation time, the cached version will be
+  # used.  If no template_path is given, template_src is used as the
+  # key to the cache.
+  #
+  # If a local variable is not present when the template is
+  # compiled, it will be ignored when the template is used.  In
+  # other words, the variable values may change, but the names may
+  # not.
+  #
+  # included_taglibs is only used during template compilation.
+  #
+  # @param [String] template_src the DRYML source
+  # @param [Hash] locals local variables.
+  # @param [String, nil] template_path the filename of the source.
+  # @param [Array] included_taglibs A list of Taglibs to include. { :src =>
+  #                    "core", :plugin => "dryml" } is automatically
+  #                    added to this list.
+  # @param [ActionView::Base] view an ActionView instance
+  def render(template_src, locals={}, template_path=nil, included_taglibs=[], view=nil)
+    template_path ||= template_src
+    view ||= ActionView::Base.new(ActionController::Base.view_paths, {})
+    this = locals.delete(:this) || nil
+
+    renderer_class = Dryml::Template.build_cache[template_path]._?.environment ||
+      make_renderer_class(template_src, template_path, locals.keys)
+    renderer_class.new(view).render_page(this, locals)
+  end
 
-      # the sum of all the names we've seen so far - eventually we'll be ready for all of 'em
-      all_local_names = renderer_class.compiled_local_names | locals
+private
 
-      template.compile(all_local_names, taglibs)
-    end
+  def taglibs_for(controller_path)
+    ( taglibs_in_dir('application').unshift(APPLICATION_TAGLIB) +
+      subsite_taglibs(controller_path) +
+      (controller_path.camelize+"Controller").constantize.try.included_taglibs||[]
+    ).compact
+  end
 
+  def subsite_taglibs(controller_path)
+    parts = controller_path.split("/")
+    subsite = parts.length >= 2 ? parts[0..-2].join('_') : "front"
+    src = "taglibs/#{subsite}_site"
+    Object.const_defined?(:Rails) && File.exists?("#{Rails.root}/app/views/#{src}.dryml") ?
+      taglibs_in_dir("#{subsite}_site").unshift({ :src => src }) : []
+  end
 
-    def unreserve(word)
-      word = word.to_s
-      if RESERVED_WORDS.include?(word)
-        word + "_"
-      else
-        word
+  def taglibs_in_dir(dir_name)
+    Dir.chdir(Rails.root) do
+      Dir["app/views/taglibs/#{dir_name}/**/*.dryml"].map{|f| File.basename f, '.dryml'}.map do |n|
+        { :src => "taglibs/#{dir_name}/#{n}" }
       end
     end
+  end
 
+  # create and compile a renderer class (AKA Dryml::Template::Environment)
+  #
+  # template_src:: the DRYML source
+  # template_path:: the filename of the source.  This is used for
+  #                 caching
+  # locals:: local variables.
+  # imports:: A list of helper modules to import.  For example, Hobo
+  #           uses [Hobo::Helper, Hobo::Helper::Translations,
+  #           ApplicationHelper]
+  # included_taglibs:: A list of Taglibs to include. { :src =>
+  #                    "core", :plugin => "dryml" } is automatically
+  #                    added to this list.
+  #
+  def make_renderer_class(template_src, template_path, locals=[], taglibs=[])
+    renderer_class = Class.new(TemplateEnvironment)
+    compile_renderer_class(renderer_class, template_src, template_path, locals, taglibs)
+    renderer_class
+  end
 
-    def static_tags
-      @static_tags ||= begin
-                         path = if Object.const_defined?(:RAILS_ROOT) && FileTest.exists?("#{RAILS_ROOT}/config/dryml_static_tags.txt")
-                                    "#{RAILS_ROOT}/config/dryml_static_tags.txt"
-                                else
-                                    File.join(File.dirname(__FILE__), "dryml/static_tags")
-                                end
-                         File.readlines(path).*.chop
-                       end
-    end
+  def compile_renderer_class(renderer_class, template_src, template_path, locals, taglibs=[])
+    template = Dryml::Template.new(template_src, renderer_class, template_path)
+    DEFAULT_IMPORTS.each {|m| template.import_module(m)}
 
-    attr_writer :static_tags
+    # the sum of all the names we've seen so far - eventually we'll be ready for all of 'em
+    all_local_names = renderer_class.compiled_local_names | locals
 
-    # Helper function for use outside Hobo/Rails
-    #
-    # Pass the template context in locals[:this]
-    #
-    # This function caches.  If the mtime of template_path is older
-    # than the last compilation time, the cached version will be
-    # used.  If no template_path is given, template_src is used as the
-    # key to the cache.
-    #
-    # If a local variable is not present when the template is
-    # compiled, it will be ignored when the template is used.  In
-    # other words, the variable values may change, but the names may
-    # not.
-    #
-    # included_taglibs is only used during template compilation.
-    #
-    # @param [String] template_src the DRYML source
-    # @param [Hash] locals local variables.
-    # @param [String, nil] template_path the filename of the source.  
-    # @param [Array] included_taglibs A list of Taglibs to include. { :src =>
-    #                    "core", :plugin => "dryml" } is automatically
-    #                    added to this list.
-    # @param [ActionView::Base] view an ActionView instance    
-    def render(template_src, locals={}, template_path=nil, included_taglibs=[], view=nil)
-      template_path ||= template_src
-      view ||= ActionView::Base.new(ActionController::Base.view_paths, {})
-      this = locals.delete(:this) || nil
+    template.compile(all_local_names, [CORE_TAGLIB]+taglibs)
+  end
 
-      renderer_class = Dryml::Template.build_cache[template_path]._?.environment ||
-        Dryml.make_renderer_class(template_src, template_path, locals.keys, [], included_taglibs)
-      renderer_class.new(template_path, view).render_page(this, locals)
-    end
-    
 end
+
+require 'dryml/railtie' if Object.const_defined?(:Rails)