dryml 1.3.0.RC4 → 1.3.0.pre10

data/lib/dryml.rb

@@ -4,234 +4,272 @@
 # Copyright:: Copyright (c) 2008
 # License::   Distributes under the same terms as Ruby
 
+
+
+# gem dependencies
 require 'hobo_support'
 require 'action_pack'
-require 'openssl'
 
-ActiveSupport::Dependencies.autoload_paths |= [File.dirname(__FILE__)]
-ActiveSupport::Dependencies.autoload_once_paths |= [File.dirname(__FILE__)]
+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__)
-  def self.root; @@root; 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 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)
+    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
-  end
-
-  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"))
+
+    TagDef = Struct.new "TagDef", :name, :attrs, :proc
+
+    RESERVED_WORDS = %w{if for while do class else elsif unless case when module in}
+
+    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 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
       end
     end
-  end
-
-  def clear_cache
-    @cache = {}
-  end
-
-  def render_tag(view, tag, options={})
-    renderer = empty_page_renderer(view)
-    renderer.render_tag(tag, options)
-  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)
-    this = view.controller.send(:dryml_context) || local_assigns[:this]
-    view.instance_variable_set("@this", this)
-    # do this last, as TemplateEnvironment copies instance variables in initalize
-    renderer = page_renderer(view, identifier, local_assigns.keys)
-    if identifier =~ /#{ID_SEPARATOR}/
-      tag_name = identifier.split(ID_SEPARATOR).last
-      renderer.render_tag(tag_name, {:with => this} )
-    else
+
+
+    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 call_render(view, local_assigns, identifier)
+      page = view.request.fullpath
+      renderer = page_renderer(view, local_assigns.keys, page, identifier)
+      this = view.controller.send(:dryml_context) || local_assigns[:this]
+      view.instance_variable_set("@this", this)
       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
-    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
+
+
+    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] + application_taglibs() + [subsite_taglib(page)] + controller_taglibs(view.controller.class)).compact
+
+      if page.ends_with?(EMPTY_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
+        mtime = File.mtime(filename)
+        renderer_class = @renderer_classes[page]
+
+        # 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)
+      end
+    end
+
+    def controller_taglibs(controller_class)
+      controller_class.try.included_taglibs || []
+    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
-      renderer_class.new(view)
-    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
-
-  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 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)
-    ( 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 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
+
+    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
+      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
+    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
     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
 

data/taglibs/core.dryml

@@ -4,9 +4,7 @@
   It's the DRYML equivalent of Ruby's `send` method.
 -->
 <def tag="call-tag" attrs="tag">
-  <%= Dryml.static_tags.include?(tag) ?
-      content_tag(tag, parameters.default, attributes) :
-      send(tag.gsub('-', '_'), attributes, parameters) %>
+  <%= send(tag.gsub('-', '_'), attributes, parameters) %>
 </def>
 
 
@@ -23,15 +21,7 @@ For example, you might want to wrap an `<img>` tag in an `<a>` tag but only unde
 -->
 <def tag="wrap" attrs="tag, when, parameter">
   <% parameter ||= :default %>
-  <%= if when_
-        if Dryml.static_tags.include?(tag)
-          content_tag(tag, parameters.default, attributes)
-        else
-          send(tag.gsub('-', '_'), attributes, { parameter.to_sym => parameters[:default] })
-        end
-      else
-        parameters.default
-      end %>
+  <%= when_ ? send(tag, attributes, { parameter.to_sym => parameters[:default] }) : parameters.default %>
 </def>
 
 
@@ -71,10 +61,10 @@ For example, you might want to wrap an `<img>` tag in an `<a>` tag but only unde
 
 ### Usage
 
-    <if test="&current_user.administrator?">Logged in as administrator</if>
+    <if test="&current_user.administrtator?">Logged in as administrator</if>
     <else>Logged in as normal user</else>
-    
-**IMPORTANT NOTE**: `<if>` tests for non-blank vs. blank (as defined by ActiveSupport), not true vs. false. 
+
+**IMPORTANT NOTE**: `<if>` tests for non-blank vs. blank (as defined by ActiveSuport), not true vs. false.
 
 If you do not give the `test` attribute, uses the current context instead. This allows a nice trick like this:
 

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/railtie/template_handler'
+        >> require 'dryml/template_handler'
 
 {.hidden}
 

metadata

@@ -1,8 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: dryml
 version: !ruby/object:Gem::Version 
-  prerelease: 6
-  version: 1.3.0.RC4
+  hash: -1637175975
+  prerelease: true
+  segments: 
+  - 1
+  - 3
+  - 0
+  - pre10
+  version: 1.3.0.pre10
 platform: ruby
 authors: 
 - Tom Locke
@@ -10,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-09 00:00:00 -05:00
+date: 2010-10-10 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -19,8 +25,13 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
         version: 3.0.0
   type: :runtime
   version_requirements: *id001
@@ -32,7 +43,13 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 1.3.0.RC4
+        hash: -1637175975
+        segments: 
+        - 1
+        - 3
+        - 0
+        - pre10
+        version: 1.3.0.pre10
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -43,6 +60,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id003
@@ -50,8 +70,8 @@ description: The Don't Repeat Yourself Markup Language
 email: tom@tomlocke.com
 executables: []
 
-extensions: 
-- ext/mkrf_conf.rb
+extensions: []
+
 extra_rdoc_files: []
 
 files: 
@@ -62,7 +82,6 @@ files:
 - TODO.txt
 - VERSION
 - dryml.gemspec
-- ext/mkrf_conf.rb
 - lib/dryml.rb
 - lib/dryml/dryml_builder.rb
 - lib/dryml/dryml_doc.rb
@@ -80,6 +99,7 @@ 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
@@ -104,17 +124,25 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
       version: 1.3.6
 requirements: []
 
 rubyforge_project: hobo
-rubygems_version: 1.6.2
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: The Don't Repeat Yourself Markup Language

data/ext/mkrf_conf.rb

@@ -1,9 +0,0 @@
-require 'rubygems'
-
-# the whole reason this file exists:   to return an error if openssl
-# isn't installed.
-require 'openssl'
-
-f = File.open(File.join(File.dirname(__FILE__), "Rakefile"), "w")   # create dummy rakefile to indicate success
-f.write("task :default\n")
-f.close