dryml 1.3.0.pre12 → 1.3.0.pre13

data/Rakefile

@@ -2,22 +2,17 @@ require 'rake'
 require 'rake/rdoctask'
 require 'rake/testtask'
 
-$:.unshift File.expand_path('../lib', __FILE__)
-$:.unshift File.expand_path('../../hobo_support/lib', __FILE__)
-require 'dryml' # to get VERSION
-
 RUBY = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name']).sub(/.*\s.*/m, '"\&"')
 RUBYDOCTEST = ENV['RUBYDOCTEST'] || "#{RUBY} -S rubydoctest"
 
-desc "Default Task"
-task :default => [ :test ]
-
 # --- Testing --- #
 
-desc "Run all tests"
-task :test do |t|
-  files=Dir['test/*.rdoctest'].map {|f| File.expand_path(f)}.join(' ')
-  exit(1) if !system("#{RUBYDOCTEST} #{files}")
+namespace "test" do
+  desc "Run the doctests"
+  task :doctest do |t|
+    files=Dir['test/**/*.rdoctest'].map {|f| File.expand_path(f)}.join(' ')
+    exit(1) if !system("#{RUBYDOCTEST} #{files}")
+  end
 end
 
 # --- RDOC --- #

data/VERSION

@@ -1 +1 @@
-1.3.0.pre12
+1.3.0.pre13

data/lib/dryml/railtie/page_tag_resolver.rb

@@ -9,11 +9,15 @@ module Dryml
 
       def find_templates(name, prefix, partial, details)
         tag_name = @controller.dryml_fallback_tag || name.dasherize + '-page'
-        text = @controller.call_dryml_tag(tag_name)
-        return [] unless text
-        [ActionView::Template.new(text, "dryml-page-tag:#{tag_name}", Dryml::Railtie::PageTagHandler, details)]
+        method_name = tag_name.to_s.gsub('-', '_')
+        if Dryml.empty_page_renderer(@controller.view_context).respond_to?(method_name)
+          [ActionView::Template.new('', Dryml.page_tag_identifier(@controller.controller_path, tag_name),
+                                    Dryml::Railtie::TemplateHandler, details)]
+        else
+          []
+        end
       end
 
-    end
+   end
   end
 end

data/lib/dryml/railtie.rb

@@ -15,5 +15,12 @@ module Dryml
       ActionView::Template.register_template_handler("dryml", Dryml::Railtie::TemplateHandler)
     end
 
+    initializer 'dryml' do |app|
+      app.config.to_prepare do
+        Dryml.clear_cache
+        Dryml::Taglib.clear_cache
+      end
+    end
+
   end
 end

data/lib/dryml/template.rb

@@ -51,7 +51,7 @@ module Dryml
     def compile(local_names=[], auto_taglibs=[])
       now = Time.now
 
-      unless @template_path.ends_with?(EMPTY_PAGE)
+      unless @template_path.blank?
         p = Pathname.new template_path
         p = Pathname.new(Rails.root) + p unless p.absolute? || !Object.const_defined?(:Rails)
         mtime = p.mtime rescue Time.now

data/lib/dryml/template_environment.rb

@@ -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,7 +48,7 @@ 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"

data/lib/dryml.rb

@@ -15,265 +15,264 @@ ActiveSupport::Dependencies.autoload_paths |= [ File.dirname(__FILE__)]
 # The Don't Repeat Yourself Markup Language
 module Dryml
 
-    VERSION = File.read(File.expand_path('../../VERSION', __FILE__)).strip
-    @@root = Pathname.new File.expand_path(File.dirname(__FILE__) + "/..")
-    def self.root; @@root; end
-
-    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
+  VERSION = File.read(File.expand_path('../../VERSION', __FILE__)).strip
+  @@root = Pathname.new File.expand_path(File.dirname(__FILE__) + "/..")
+  def self.root; @@root; end
+
+  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
+  TagDef = Struct.new "TagDef", :name, :attrs, :proc
 
-    RESERVED_WORDS = %w{if for while do class else elsif unless case when module in}
+  RESERVED_WORDS = %w{if for while do class else elsif unless case when module in}
 
-    EMPTY_PAGE = "[tag-page]"
+  ID_SEPARATOR = '; dryml-tag: '
+  APPLICATION_TAGLIB = { :src => "taglibs/application" }
+  CORE_TAGLIB        = { :src => "core", :plugin => "dryml" }
 
-    APPLICATION_TAGLIB = { :src => "taglibs/application" }
-    CORE_TAGLIB        = { :src => "core", :plugin => "dryml" }
+  DEFAULT_IMPORTS = defined?(ApplicationHelper) ? [ApplicationHelper] : []
 
-    DEFAULT_IMPORTS = defined?(ApplicationHelper) ? [ApplicationHelper] : []
+  @cache = {}
 
-    @renderer_classes = {}
-    @tag_page_renderer_classes = {}
+  extend self
 
-    extend self
+  attr_accessor :last_if
 
-    attr_accessor :last_if
 
-
-    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
+  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
-      @renderer_classes = {}
-      @tag_page_renderer_classes = {}
-    end
+  def clear_cache
+    @cache = {}
+  end
 
-    def render_tag(view, tag, options={})
-      renderer = empty_page_renderer(view)
-      renderer.render_tag(tag, options)
-    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 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 call_render(view, local_assigns, identifier)
-      page_path = view.request.fullpath
-      renderer = page_renderer(view, page_path, local_assigns.keys, identifier)
-      this = view.controller.send(:dryml_context) || local_assigns[:this]
-      view.instance_variable_set("@this", this)
+  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 page_renderer(view, identifier, local_names=[], controller_path=nil)
+    controller_path ||= view.controller.controller_path
+  #  prepare_view!(view)
+    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 page_renderer(view, page_path, local_names=[], identifier=nil)
-
-      prepare_view!(view)
-      included_taglibs = ([APPLICATION_TAGLIB] + application_taglibs() + [subsite_taglib(page_path)] + controller_taglibs(view.controller.class)).compact
-
-      if identifier.blank? && ! page_path.ends_with?(EMPTY_PAGE)
-        opt = ActionController::Routing::Routes.recognize_path(page_path)
-        identifier = view.view_paths.find( opt[:action],
-                                           opt[:controller],
-                                           false,
-                                           view.lookup_context.instance_variable_get('@details')).identifier
-      end
-      if page_path.ends_with?(EMPTY_PAGE) || identifier.starts_with?('dryml-page-tag:')
-        controller_class = view.controller.class
-        @tag_page_renderer_classes[controller_class.name] ||=
-          make_renderer_class("", page_path, local_names, DEFAULT_IMPORTS, included_taglibs)
-        @tag_page_renderer_classes[controller_class.name].new(page_path, view)
+  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
-        mtime = File.mtime(identifier)
-        renderer_class = @renderer_classes[page_path]
-
-        # 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,
-                                               DEFAULT_IMPORTS, included_taglibs)
-          renderer_class.load_time = mtime
-          @renderer_classes[page_path] = renderer_class
-        end
-        renderer_class.new(page_path, view)
+        return object[field]
       end
     end
-
-    def controller_taglibs(controller_class)
-      controller_class.try.included_taglibs || []
-    end
+  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) && File.exists?("#{Rails.root}/app/views/#{src}.dryml")
-    end
-
-    def application_taglibs
-      Dir.chdir(Rails.root) do
-        Dir["app/views/taglibs/application/**/*.dryml"].map{|f| File.basename f, '.dryml'}.map do |n|
-          { :src => "taglibs/application/#{n}" }
-        end
-      end
-    end
+  def get_field_path(object, path)
+    path = if path.is_a? String
+             path.split('.')
+           else
+             Array(path)
+           end
 
-    def get_field(object, field)
+    parent = nil
+    path.each do |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
-      end
+      parent = object
+      object = get_field(parent, field)
     end
+    [parent, path.last, object]
+  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]
+  def unreserve(word)
+    word = word.to_s
+    if RESERVED_WORDS.include?(word)
+      word + "_"
+    else
+      word
     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
-                    @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 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
+
+  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
+
+private
+
+  def taglibs_for(controller_path)
+    ([APPLICATION_TAGLIB] +
+    application_taglibs() +
+    [subsite_taglib(controller_path)] +
+    (controller_path.camelize+"Controller").constantize.try.included_taglibs||[]).compact
+  end
+
+  def application_taglibs
+    Dir.chdir(Rails.root) do
+      Dir["app/views/taglibs/application/**/*.dryml"].map{|f| File.basename f, '.dryml'}.map do |n|
+        { :src => "taglibs/application/#{n}" }
       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=[], imports=[], included_taglibs=[])
-      renderer_class = Class.new(TemplateEnvironment)
-      compile_renderer_class(renderer_class, template_src, template_path, locals, imports, included_taglibs)
-      renderer_class
-    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)}
-
-      taglibs = [CORE_TAGLIB] + included_taglibs
-
-      # 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
-
-      template.compile(all_local_names, taglibs)
-    end
-
-
-    def unreserve(word)
-      word = word.to_s
-      if RESERVED_WORDS.include?(word)
-        word + "_"
-      else
-        word
+  end
+
+  def subsite_taglib(controller_path)
+    parts = controller_path.split("/")
+    subsite = parts.length >= 2 ? parts[0..-2].join('_') : "front"
+    src = "taglibs/#{subsite}_site"
+    { :src => src } if Object.const_defined?(:Rails) && File.exists?("#{Rails.root}/app/views/#{src}.dryml")
+  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
+                  @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
+  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 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)}
+
+    # 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
+
+    template.compile(all_local_names, [CORE_TAGLIB]+taglibs)
+  end
 
 
-    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
-
-    attr_writer :static_tags
-
-    # 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 ||
-        Dryml.make_renderer_class(template_src, template_path, locals.keys)
-      renderer_class.new(template_path, view).render_page(this, locals)
-    end
-
 end
 
 require 'dryml/railtie' if Object.const_defined?(:Rails)

data/test/dryml.rdoctest

@@ -7,7 +7,7 @@
         >> $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), '../../dryml/lib')
         >> require 'hobo_support'
         >> require 'dryml'
-        >> require 'dryml/template_handler'
+        >> require 'dryml/railtie/template_handler'
 
 {.hidden}
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: dryml
 version: !ruby/object:Gem::Version 
-  hash: -1637175961
+  hash: -1637175964
   prerelease: true
   segments: 
   - 1
   - 3
   - 0
-  - pre12
-  version: 1.3.0.pre12
+  - pre13
+  version: 1.3.0.pre13
 platform: ruby
 authors: 
 - Tom Locke
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-14 00:00:00 -04:00
+date: 2010-10-20 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -43,13 +43,13 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: -1637175961
+        hash: -1637175964
         segments: 
         - 1
         - 3
         - 0
-        - pre12
-        version: 1.3.0.pre12
+        - pre13
+        version: 1.3.0.pre13
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -99,7 +99,6 @@ files:
 - lib/dryml/parser/tree_parser.rb
 - lib/dryml/part_context.rb
 - lib/dryml/railtie.rb
-- lib/dryml/railtie/page_tag_handler.rb
 - lib/dryml/railtie/page_tag_resolver.rb
 - lib/dryml/railtie/template_handler.rb
 - lib/dryml/scoped_variables.rb

data/lib/dryml/railtie/page_tag_handler.rb

@@ -1,13 +0,0 @@
-module Dryml
-  class Railtie
-    class PageTagHandler < ActionView::Template::Handler
-
-      self.default_format = Mime::HTML
-
-      def self.call(template)
-        "ActionView::Template::Text.new(%q(#{template.source}), Mime::HTML).render"
-      end
-
-    end
-  end
-end