hobo 0.8.3 → 0.8.4

data/lib/hobo/authentication_support.rb

@@ -90,21 +90,27 @@ module Hobo
     # When called with before_filter :login_from_cookie will check for an :auth_token
     # cookie and log the user back in if apropriate
     def login_from_cookie
-      return unless (token = cookies[:auth_token]) && !logged_in?
-
-      user_model = token[:user_model].constantize
-      user = user_model.find_by_remember_token(token)
-      if user && user.remember_token?
+      if (user = authenticated_user_from_cookie)
         user.remember_me
-        current_user = user
+        self.current_user = user
         create_auth_cookie
       end
     end
+    
+    
+    def authenticated_user_from_cookie
+      !logged_in? and
+          cookie = cookies[:auth_token] and
+          (token, model_name = cookie.split) and
+          user_model = model_name.constantize rescue nil and
+          user = user_model.find_by_remember_token(token) and
+          user.remember_token? and
+          user
+    end
 
     def create_auth_cookie
-      cookies[:auth_token] = { :value => current_user.remember_token ,
-                               :expires => current_user.remember_token_expires_at,
-                               :user_model => current_user.model }
+      cookies[:auth_token] = { :value => "#{current_user.remember_token} #{current_user.class.name}",
+                               :expires => current_user.remember_token_expires_at }
     end
 
     private

data/lib/hobo/composite_model.rb

@@ -56,7 +56,7 @@ module Hobo
 
 
     def typed_id
-      "#{self.class.name.underscore}_#{id}"
+      "#{self.class.name.underscore}:#{id}"
     end
 
 

data/lib/hobo/controller.rb

@@ -15,6 +15,7 @@ module Hobo
       def included_in_class(klass)
         klass.extend(ClassMethods)
         klass.class_eval do
+          before_filter :login_from_cookie 
           alias_method_chain :redirect_to, :object_url
           around_filter do |controller, action|
             Thread.current['Hobo::current_controller'] = controller
@@ -66,11 +67,10 @@ module Hobo
 
     def hobo_ajax_response(*args)
       results = args.extract_options!
-      this = args.first || @this
       page_path = params[:page_path]
       r = params[:render]
       if r
-        ajax_update_response(this, page_path, r.values, results)
+        ajax_update_response(page_path, r.values, results)
         true
       else
         false
@@ -78,8 +78,8 @@ module Hobo
     end
 
 
-    def ajax_update_response(this, page_path, render_specs, results={})
-      add_variables_to_assigns
+    def ajax_update_response(page_path, render_specs, results={})
+      @template.send(:_evaluate_assigns_and_ivars)
       renderer = Hobo::Dryml.page_renderer(@template, [], page_path) if page_path
 
       render :update do |page|
@@ -89,12 +89,11 @@ module Hobo
           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)
+            part_content = renderer.refresh_part(spec[:part_context], session, dom_id)
             page.call(function, dom_id, part_content)
           elsif spec[:result]
             result = results[spec[:result].to_sym]
-            page.call(function, spec[:id], result)
+            page.call(function, dom_id, result)
           else
             # spec didn't specify any action :-/
           end
@@ -168,7 +167,7 @@ end
 class ActionController::Base
 
   def home_page
-    ""
+    base_url
   end
 
 end

data/lib/hobo/dryml.rb

@@ -58,12 +58,12 @@ module Hobo
     end
 
 
-    def page_renderer_for_template(view, template)
-      page_renderer(view, template.locals.keys, template.path_without_extension)
+    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)
+    def page_renderer(view, local_names=[], page=nil, filename=nil)
       if RAILS_ENV == "development"
         clear_cache
         Taglib.clear_cache
@@ -79,16 +79,15 @@ module Hobo
           make_renderer_class("", page, local_names, DEFAULT_IMPORTS, included_taglibs)
         @tag_page_renderer_classes[controller_class.name].new(page, view)
       else
-        template_path = view.finder.pick_template(page, "dryml")
- 
-        mtime = File.mtime(template_path)
+        filename ||= view._pick_template(page + ".dryml").filename
+        mtime = File.mtime(filename)
         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?
+        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(template_path), template_path, local_names,
+          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
@@ -106,7 +105,7 @@ module Hobo
 
 
     def controller_taglibs(controller_class)
-      (controller_class.respond_to?(:included_taglibs) && controller_class.included_taglibs) || []
+      controller_class.try.included_taglibs || []
     end
 
 

data/lib/hobo/dryml/dryml_builder.rb

@@ -62,7 +62,13 @@ module Hobo::Dryml
       # Strip off "_erbout = ''" from the beginning and "; _erbout"
       # from the end, because we do things differently around
       # here. (_erbout is defined as a method)
-      ERB.new(erb_src, nil, ActionView::Base.erb_trim_mode).src[("_erbout = '';").length..-("; _erbout".length)]
+      trim_mode = if defined?(ActionView::TemplateHandlers::ERB.erb_trim_mode)
+                    ActionView::TemplateHandlers::ERB.erb_trim_mode
+                  else
+                    ActionView::Base.erb_trim_mode
+                  end
+      
+      ERB.new(erb_src, nil, trim_mode).src[("_erbout = '';").length..-("; _erbout".length)]
     end
 
 

data/lib/hobo/dryml/dryml_doc.rb

@@ -0,0 +1,161 @@
+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
+      
+      class Taglib
+        
+        def initialize(home, filename)
+          @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
+        
+        def comment_html
+          Maruku.new(comment).to_html
+        end
+        
+           
+        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
+        
+        
+        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(/&amp;/, '&'); end"
+        end
+        
+        def comment_html
+          
+        end
+        
+        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

data/lib/hobo/dryml/dryml_generator.rb

@@ -13,6 +13,7 @@ module Hobo
       HEADER = "<!-- AUTOMATICALLY GENERATED FILE - DO NOT EDIT -->\n\n"
       
       def self.run
+        return if RAILS_ENV == "production"
         @generator ||= DrymlGenerator.new
         @generator.run
       end
@@ -137,15 +138,6 @@ module Hobo
       end
 
       
-      def primary_collection_name(klass=model)
-        dependent_collection_names = klass.reflections.values.select do |refl|
-          refl.macro == :has_many && refl.options[:dependent]
-        end.*.name
-
-        (dependent_collection_names - through_collection_names(klass)).first
-      end
-
-
       def through_collection_names(klass=model)
         klass.reflections.values.select do |refl|
           refl.macro == :has_many && refl.options[:through]
@@ -199,6 +191,23 @@ module Hobo
       end
       
       
+      def creators
+        defined?(model::Lifecycle) ? model::Lifecycle.publishable_creators : []
+      end
+      
+      def transitions
+        defined?(model::Lifecycle) ? model::Lifecycle.publishable_transitions : []
+      end
+            
+      def creator_names
+        creators.map { |c| c.name.to_s }
+      end
+      
+      def transition_names
+        transitions.map { |t| t.name.to_s }.uniq
+      end
+      
+      
       def a_or_an(word)
         (word =~ /^[aeiou]/i ? "an " : "a ") + word
       end

data/lib/hobo/dryml/part_context.rb

@@ -7,7 +7,7 @@ module Hobo
 
       class TamperedWithPartContext < StandardError; end
 
-      class Id < String; end
+      class TypedId < String; end
 
       class << self
         attr_accessor :secret, :digest
@@ -23,75 +23,109 @@ module Hobo
           "hoboParts['#{dom_id}'] = (#{code});\n"
         end.join
       end
-
-
-      def initialize(part_name, this_id, locals)
-        @part_name = part_name
-        @this_id = this_id
-        @locals = locals.map { |l| pre_marshal(l) }
-      end
-
-
-      def pre_marshal(x)
+      
+      
+      def self.pre_marshal(x)
         if x.is_a?(ActiveRecord::Base) && x.respond_to?(:typed_id)
-          Id.new(x.typed_id)
+          TypedId.new(x.typed_id)
         else
           x
         end
       end
 
 
+      def self.for_call(part_name, environment, locals)
+        new do |c|
+          c.part_name       = part_name
+          c.locals          = locals.map { |l| pre_marshal(l) }
+          c.this_id         = environment.typed_id
+          c.form_field_path = environment.form_field_path
+        end
+      end
+      
+      
+      def self.for_refresh(encoded_context, page_this, session)
+        new do |c|
+          c.unmarshal(encoded_context, page_this, session)
+        end
+      end
+      
+      
+      def initialize
+        yield self
+      end
+      
+      attr_accessor :part_name, :locals, :this, :this_field, :this_id, :form_field_path
+
+
       def marshal(session)
         context = [@part_name, @this_id, @locals]
+        context << form_field_path if form_field_path
         data = Base64.encode64(Marshal.dump(context)).strip
-        digest = self.class.generate_digest(data, session)
+        digest = generate_digest(data, session)
         "#{data}--#{digest}"
       end
 
 
-      class << self
+      # Unmarshal part context to a hash and verify its integrity.
+      def unmarshal(client_store, page_this, session)
+        data, digest = CGI.unescape(client_store).strip.split('--')
 
-        # Generate the HMAC keyed message digest. Uses SHA1 by default.
-        def generate_digest(data, session)
-          secret = self.secret || ActionController::Base.cached_session_options.first[:secret]
-          key = secret.respond_to?(:call) ? secret.call(session) : secret
-          OpenSSL::HMAC.hexdigest(OpenSSL::Digest::Digest.new(digest), key, data)
-        end
+        raise TamperedWithPartContext unless digest == generate_digest(data, session)
 
+        context = Marshal.load(Base64.decode64(data))
+        
+        part_name, this_id, locals, form_field_path = context
 
-        # Unmarshal part context to a hash and verify its integrity.
-        def unmarshal(client_store, this, session)
-          data, digest = CGI.unescape(client_store).strip.split('--')
+        RAILS_DEFAULT_LOGGER.info "Call part: #{part_name}. this-id = #{this_id}, locals = #{locals.inspect}"
+        RAILS_DEFAULT_LOGGER.info "         : form_field_path = #{form_field_path.inspect}" if form_field_path
+        
+        self.part_name             = part_name
+        self.this_id               = this_id
+        self.locals                = restore_locals(locals)
+        self.form_field_path       = form_field_path
+        
+        parse_this_id(page_this)        
+      end
 
-          raise TamperedWithPartContext unless digest == generate_digest(data, session)
 
-          part_name, this_id, locals = Marshal.load(Base64.decode64(data))
-          RAILS_DEFAULT_LOGGER.info("Call part: #{part_name}. this-id = #{this_id}, locals = #{locals.inspect}")
+      # Generate the HMAC keyed message digest. Uses SHA1 by default.
+      def generate_digest(data, session)
+        secret = self.class.secret || ActionController::Base.cached_session_options.first[:secret]
+        key = secret.respond_to?(:call) ? secret.call(session) : secret
+        OpenSSL::HMAC.hexdigest(OpenSSL::Digest::Digest.new(self.class.digest), key, data)
+      end
 
-          [part_name, restore_part_this(this_id, this), restore_locals(locals)]
-        end
 
-        def restore_part_this(this_id, this)
-          if this_id == "this" or this_id.blank?
-            this
-          elsif this_id == "nil"
-            nil
+
+      def parse_this_id(page_this)
+        if this_id == "this"
+          self.this = page_this
+        elsif this_id =~ /^this:(.*)/
+          self.this = page_this
+          self.this_field = $1
+        elsif this_id == "nil"
+          nil
+        else
+          parts = this_id.split(':')
+          if parts.length == 3
+            self.this       = Hobo::Model.find_by_typed_id("#{parts[0]}:#{parts[1]}")
+            self.this_field = parts[2]
           else
-            Hobo.object_from_dom_id(this_id)
+            self.this = Hobo::Model.find_by_typed_id(this_id)
           end
         end
+      end
 
 
-        def restore_locals(locals)
-          locals.map do |l|
-            if l.is_a?(Id)
-              Hobo.object_from_dom_id(l)
-            else
-              l
-            end
+      def restore_locals(locals)
+        locals.map do |l|
+          if l.is_a?(TypedId)
+            Hobo::Model.find_by_typed_id(this_id)
+          else
+            l
           end
         end
-
       end
 
     end