hobo 0.7.5 → 0.8

data/{hobo_files/plugin/lib → lib}/hobo/controller.rb

@@ -3,15 +3,15 @@ module Hobo
   module Controller
 
     include AuthenticationSupport
-    
+
     class << self
-      
+
       def included(base)
         if base.is_a?(Class)
           included_in_class(base)
         end
       end
-      
+
       def included_in_class(klass)
         klass.extend(ClassMethods)
         klass.class_eval do
@@ -20,11 +20,13 @@ module Hobo
         end
         Hobo::HoboHelper.add_to_controller(klass)
       end
-      
+
+      attr_accessor :request_host, :app_name
+
       def controller_and_view_for(page_path)
         page_path.match(/(.*)\/([^\/]+)/)[1..2]
       end
-      
+
     end
 
     module ClassMethods
@@ -34,12 +36,12 @@ module Hobo
       def include_taglib(src, options={})
         @included_taglibs << options.merge(:src => src)
       end
-      
+
     end
 
-    
+
     protected
-    
+
     def redirect_to_with_object_url(destination, *args)
       if destination.is_a?(String, Hash, Symbol)
         redirect_to_without_object_url(destination)
@@ -48,7 +50,7 @@ module Hobo
       end
     end
 
-    
+
     def hobo_ajax_response(*args)
       results = args.extract_options!
       this = args.first || @this
@@ -72,7 +74,7 @@ module Hobo
         for spec in render_specs
           function = spec[:function] || "_update"
           dom_id = spec[:id]
-          
+
           if spec[:part_context]
             part_name, part_this, locals = Dryml::PartContext.unmarshal(spec[:part_context], this, session)
             part_content = renderer.call_part(dom_id, part_name, part_this, *locals)
@@ -87,8 +89,8 @@ module Hobo
         page << renderer.part_contexts_storage if renderer
       end
     end
-    
-    
+
+
     def dryml_context
       @this
     end
@@ -96,17 +98,28 @@ module Hobo
 
     def render_tags(objects, tag, options={})
       for_type = options.delete(:for_type)
-      add_variables_to_assigns
-      dryml_renderer = Hobo::Dryml.empty_page_renderer(@template)
-      
-      results = objects.map do |o| 
-        tag = dryml_renderer.find_polymorphic_tag(tag, o.class) if for_type
-        dryml_renderer.send(tag, options.merge(:with => o))
+
+      results = objects.map do |o|
+        tag = tag_renderer.find_polymorphic_tag(tag, o.class) if for_type
+        tag_renderer.send(tag, options.merge(:with => o))
       end.join
-      
-      render :text => results + dryml_renderer.part_contexts_storage
-    end
 
+      render :text => results + tag_renderer.part_contexts_storage
+    end
+    
+    
+    def tag_renderer
+      @tag_renderer ||= begin
+        add_variables_to_assigns
+        Hobo::Dryml.empty_page_renderer(@template)
+      end
+    end    
+    
+    
+    def call_tag(name, options={})
+      tag_renderer.send(name, options)
+    end
+    
 
     def site_search(query)
       results = Hobo.find_by_search(query).select{|r| Hobo.can_view?(current_user, r, nil)}
@@ -129,9 +142,9 @@ module Hobo
     def request_no_cache?
       request.env['HTTP_CACHE_CONTROL'] =~ /max-age=\s*0/
     end
-    
+
     def not_found
-      
+
     end
 
   end
@@ -139,9 +152,9 @@ end
 
 
 class ActionController::Base
-  
+
   def home_page
     ""
   end
-  
+
 end

data/{hobo_files/plugin/lib → lib}/hobo/dev_controller.rb

@@ -1,21 +1,25 @@
 class Hobo::DevController < ActionController::Base
-  
+
   hobo_controller
-  
+
   before_filter :developer_modes_only
   
   def set_current_user
     model = params[:model] || Hobo::User.default_user_model
-    self.current_user = params[:name] ? model[params[:name]] : model.find(params[:id])
+    self.current_user = if params[:login]
+                          model.find(:first, :conditions => {model.login_attribute => params[:login]})
+                        else
+                          model.find(params[:id])
+                        end
     redirect_to(request.env["HTTP_REFERER"] ? :back : home_page)
   end
-  
+
   private
-  
+
   def developer_modes_only
     # Belt and braces. In addition to this check, the routes only get
     # defined when developer_features? is true
     render :text => "Permission Denied", :status => 403 unless Hobo.developer_features?
   end
-  
+
 end

data/lib/hobo/dryml.rb

@@ -0,0 +1,167 @@
+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, ApplicationHelper]
+                       else
+                         [Hobo::HoboHelper]
+                       end)
+
+    @renderer_classes = {}
+    @tag_page_renderer_classes = {}
+
+    extend self
+
+    attr_accessor :last_if
+    
+    def enable
+      ActionView::Template.register_template_handler("dryml", Hobo::Dryml::TemplateHandler)
+    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, template)
+      page_renderer(view, template.locals.keys, template.path_without_extension)
+    end
+
+
+    def page_renderer(view, local_names=[], page=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
+        template_path = "app/views/" + page + ".dryml"
+        src_file = File.join(RAILS_ROOT, template_path)
+        mtime = File.mtime(src_file)
+        renderer_class = @renderer_classes[page]
+
+        # do we need to recompile?
+        if (!renderer_class or                                          # nothing cached?
+            (local_names - renderer_class.compiled_local_names).any? or # any new local names?
+            renderer_class.load_time < mtime)                           # cache out of date?
+          renderer_class = make_renderer_class(File.read(src_file), template_path, 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.respond_to?(:included_taglibs) && controller_class.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/{hobo_files/plugin/lib → lib}/hobo/dryml/dryml_builder.rb

@@ -1,15 +1,15 @@
 module Hobo::Dryml
-  
+
   class DRYMLBuilder
 
     def initialize(template)
       @template = template
-      @build_instructions = Array.new
+      @build_instructions = nil # set to [] on the first add_build_instruction
       @part_names = []
     end
-    
+
     attr_reader :template
-    
+
     def template_path
       template.template_path
     end
@@ -20,22 +20,22 @@ module Hobo::Dryml
     end
 
 
-    def ready?(mtime)
-      !@build_instructions.empty? && @last_build_mtime && @last_build_mtime >= mtime
+    def ready?(mtime, d=false)
+      @build_instructions && @last_build_mtime && @last_build_mtime >= mtime
     end
 
 
-    def clear_instructions
+    def start
       @part_names.clear
-      @build_instructions.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)
@@ -56,8 +56,8 @@ module Hobo::Dryml
             src +
            "; _erbout; end; end")
     end
-    
-    
+
+
     def erb_process(erb_src)
       # Strip off "_erbout = ''" from the beginning and "; _erbout"
       # from the end, because we do things differently around
@@ -69,39 +69,42 @@ module Hobo::Dryml
     def build(local_names, auto_taglibs, src_mtime)
 
       auto_taglibs.each { |t| import_taglib(t) }
-    
-      @build_instructions.each do |instruction|
+
+      @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])
           @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]}, " + 
+          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]
@@ -109,10 +112,10 @@ module Hobo::Dryml
       else
         template_dir = File.dirname(template_path)
         options = options.merge(:template_dir => template_dir)
-        
+
         # Pass on the current bundle, if there is one, to the sub-taglib
         options[:bundle] = template.bundle.name unless template.bundle.nil? || options[:bundle] || options[:plugin]
-        
+
         taglib = Taglib.get(options)
         taglib.import_into(@environment, options[:as])
       end
@@ -123,7 +126,7 @@ module Hobo::Dryml
       raise NotImplementedError if as
       @environment.send(:include, mod)
     end
-  
+
 
     def set_theme(name)
       if Hobo.current_theme.nil? or Hobo.current_theme == name