hobo 1.0.3 → 1.1.0.pre0

data/lib/hobo/dryml.rb

@@ -1,188 +0,0 @@
-module Hobo
-
-  module Dryml
-
-    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
-
-    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 => "hobo" }
-
-    DEFAULT_IMPORTS = (if defined?(ApplicationHelper)
-                         [Hobo::HoboHelper, Hobo::Translations, ApplicationHelper]
-                       else
-                         [Hobo::HoboHelper, Hobo::Translations]
-                       end)
-
-    @renderer_classes = {}
-    @tag_page_renderer_classes = {}
-
-    extend self
-
-    attr_accessor :last_if
-    
-    def enable
-      ActionView::Template.register_template_handler("dryml", Hobo::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
-    end
-    
-    
-    def precompile_taglibs
-      Dir.chdir(RAILS_ROOT) do
-        taglibs = Dir["vendor/plugins/**/taglibs/**/*.dryml"] + Dir["app/views/taglibs/**/*.dryml"]
-        taglibs.each do |f|
-          Hobo::Dryml::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 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 = ([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]
-
-        # 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
-
-
-    # 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 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 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
-                    @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
-
-
-    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, APPLICATION_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
-
-end

data/lib/hobo/dryml/dryml_builder.rb

@@ -1,140 +0,0 @@
-module Hobo::Dryml
-
-  class DRYMLBuilder
-
-    def initialize(template)
-      @template = template
-      @build_instructions = nil # set to [] on the first add_build_instruction
-      @part_names = []
-    end
-
-    attr_reader :template
-
-    def template_path
-      template.template_path
-    end
-
-
-    def set_environment(environment)
-      @environment = environment
-    end
-
-
-    def ready?(mtime, d=false)
-      @build_instructions && @last_build_mtime && @last_build_mtime >= mtime
-    end
-
-
-    def start
-      @part_names.clear
-      @build_instructions = []
-    end
-
-
-    def add_build_instruction(type, params)
-      @build_instructions << params.merge(:type => type)
-    end
-
-
-    def add_part(name, src, line_num)
-      raise DrymlException.new("duplicate part: #{name}", template_path, line_num) if name.in?(@part_names)
-      add_build_instruction(:def, :src => src, :line_num => line_num)
-      @part_names << name
-    end
-
-
-    def <<(params)
-      @build_instructions << params
-    end
-
-
-    def render_page_source(src, local_names)
-      locals = local_names.map{|l| "#{l} = __local_assigns__[:#{l}];"}.join(' ')
-
-      ("def render_page(__page_this__, __local_assigns__); " +
-            "#{locals} new_object_context(__page_this__) do " +
-            src +
-           "; output_buffer; end; end")
-    end
-
-
-    def erb_process(erb_src, method_def=false)
-      trim_mode = ActionView::TemplateHandlers::ERB.erb_trim_mode
-      erb = ERB.new(erb_src, nil, trim_mode, "output_buffer")
-      src = erb.src.split(';')[1..-2].join(';')
-      
-      if method_def
-        src.sub /^\s*def.*?\(.*?\)/, '\0 __in_erb_template=true; '
-      else
-        "__in_erb_template=true; " + src
-      end
-    end
-
-
-    def build(local_names, auto_taglibs, src_mtime)
-
-      auto_taglibs.each { |t| import_taglib(t) }
-
-      @build_instructions._?.each do |instruction|
-        name = instruction[:name]
-        case instruction[:type]
-        when :eval
-          @environment.class_eval(instruction[:src], template_path, instruction[:line_num])
-
-        when :def
-          src = erb_process(instruction[:src], true)
-          @environment.class_eval(src, template_path, instruction[:line_num])
-
-        when :render_page
-          method_src = render_page_source(erb_process(instruction[:src]), local_names)
-          @environment.compiled_local_names = local_names
-          @environment.class_eval(method_src, template_path, instruction[:line_num])
-
-        when :include
-          import_taglib(instruction)
-
-        when :module
-          import_module(name.constantize, instruction[:as])
-
-        when :set_theme
-          set_theme(name)
-
-        when :alias_method
-          @environment.send(:alias_method, instruction[:new], instruction[:old])
-
-        else
-          raise RuntimeError.new("DRYML: Unknown build instruction :#{instruction[:type]}, " +
-                                 "building #{template_path}")
-        end
-      end
-      @last_build_mtime = src_mtime
-    end
-
-
-    def import_taglib(options)
-      if options[:module]
-        import_module(options[:module].constantize, options[:as])
-      else
-        template_dir = File.dirname(template_path)
-        options = options.merge(:template_dir => template_dir)
-
-        taglib = Taglib.get(options)
-        taglib.import_into(@environment, options[:as])
-      end
-    end
-
-
-    def import_module(mod, as=nil)
-      raise NotImplementedError if as
-      @environment.send(:include, mod)
-    end
-
-
-    def set_theme(name)
-      if Hobo.current_theme.nil? or Hobo.current_theme == name
-        Hobo.current_theme = name
-        import_taglib(:src => "taglibs/themes/#{name}/#{name}")
-      end
-    end
-  end
-end

data/lib/hobo/dryml/dryml_doc.rb

@@ -1,159 +0,0 @@
-require 'rexml/xpath'
-
-module Hobo
-  
-  module Dryml
-
-    # DrymlDoc provides the facility to parse a directory tree of DRYML taglibs, building a collection of objects that provide metadata
-    module DrymlDoc
-      
-      def self.load_taglibs(directory, taglib_class=DrymlDoc::Taglib)
-        dryml_files = Dir["#{directory}/**/*.dryml"]
-
-        dryml_files.map { |f| taglib_class.new(directory, f) }
-      end
-      
-      CommentMethods = classy_module do
-        
-        def comment_intro
-          comment && comment =~ /(.*?)^#/m ? $1 : comment
-        end
-
-        
-        def comment_rest
-          comment && comment[comment_intro.length..-1]
-        end
-
-        %w(comment comment_intro comment_rest).each do |m|
-          class_eval "def #{m}_html; Maruku.new(#{m}).to_html.gsub(/&/, '&'); end"
-        end
-        
-      end
-      
-      class Taglib
-        
-        def initialize(home, filename, name=nil)
-          @name = name || filename.sub(/.dryml$/, '')[home.length+1..-1]
-          @doc = Hobo::Dryml::Parser::Document.new(File.read(filename), filename)
-          parse_tag_defs
-        end
-        
-        attr_reader :name, :doc, :tag_defs
-        
-        def comment
-          first_node = doc[0][0]
-          doc.restore_erb_scriptlets(first_node.to_s.strip) if first_node.is_a?(REXML::Comment)
-        end
-        
-        include CommentMethods
-           
-        private   
-             
-        def tagdef_class
-          self.class.parent.const_get('TagDef')
-        end
-        
-        def parse_tag_defs
-          @tag_defs = []
-          REXML::XPath.match(doc, '/*/*[@tag]').each { |node| @tag_defs << tagdef_class.new(self, node) }
-        end
-        
-      end
-      
-      class TagDef
-        
-        def initialize(taglib, node)
-          @taglib = taglib
-          @node = node
-        end
-        
-        attr_reader :taglib, :node
-        delegate :doc, :to => :taglib
-        
-        
-        def name
-          node.attributes['tag']
-        end
-        
-        def source
-          doc.restore_erb_scriptlets(node.to_s).strip
-        end
-        
-        # The contents of the XML comment, if any, immediately above the tag definition
-        def comment
-          @comment ||= begin
-            space = node.previous_sibling and
-              space.to_s.blank? && space.to_s.count("\n") == 1 and
-              comment_node = space.previous_sibling
-
-            if comment_node.is_a?(REXML::Comment)
-              doc.restore_erb_scriptlets(comment_node.to_s.strip)
-            end
-          end
-        end
-        
-        include CommentMethods
-        
-        def no_doc?
-          comment =~ /^nodoc\b/
-        end
-        
-        # An array of the arrtibute names defined by this tag
-        def attributes
-          (node.attributes['attrs'] || "").split(/\s*,\s*/).where_not.blank?
-        end
-        
-        
-        # Returns a recursive array srtucture, where each item in the array is a pair: [parameter_name, sub_parameters]
-        # (sub-parameters is the same kind of structure)
-        def parameters(element=node)
-          result = []
-          element.elements.each do |e|
-            if (p = e.attributes['param'])
-              param_name = p == "&true" ? e.name : p
-              result << [param_name, parameters(e)]
-            else
-              result.concat(parameters(e))
-            end
-          end
-          result
-        end
-        
-        
-        # Is this the base definition of a polymorphic tag
-        def polymorphic?
-          node.attributes['polymorphic'].present?
-        end
-        
-        # Is this an <extend>?
-        def extension?
-          node.name == "extend"
-        end
-        
-        
-        # The definition's 'for' attribute
-        def for_type
-          node.attributes['for']
-        end
-        
-
-        # The name of the tag, if any, that this definition merges its parameters into
-        # That is, the tag with 'merge' or 'merge-params' declared
-        def merge_params
-          REXML::XPath.first(node, ".//*[@merge|@merge-params]")._?.name
-        end
-        
-        # The name of the tag, if any, that this definition merges its attributes into
-        # That is, the tag with 'merge' or 'merge-attrs' declared        
-        def merge_attrs
-          REXML::XPath.first(node, ".//*[@merge|@merge-attrs]")._?.name
-        end
-        
-      end
-      
-      
-    end
-    
-  end
-  
-end