hobo 0.5.3 → 0.6

data/hobo_files/plugin/lib/hobo/authenticated_user.rb

@@ -4,10 +4,22 @@ module Hobo
 
   module AuthenticatedUser
 
+    # Extend the base class with AuthenticatedUser functionality
+    # This includes:
+    # - plaintext password during login and encrypted password in the database
+    # - plaintext password validation
+    # - login token for rembering a login during multiple browser sessions
     def self.included(base)
       base.extend(ClassMethods)
 
       base.class_eval do
+        fields do
+          crypted_password          :string, :limit => 40
+          salt                      :string, :limit => 40
+          remember_token            :string
+          remember_token_expires_at :datetime
+        end
+        
         # Virtual attribute for the unencrypted password
         attr_accessor :password
 
@@ -25,8 +37,10 @@ module Hobo
       end
     end
 
+    # Additional classmethods for AuthenticatedUser
     module ClassMethods
       
+      # Validation of the plaintext password
       def password_validations
         validates_length_of :password, :within => 4..40, :if => :password_required?
       end
@@ -49,7 +63,11 @@ module Hobo
         u = find(:first, :conditions => ["#{@login_attr} = ?", login]) # need to get the salt
         
         if u && u.authenticated?(password)
-          u.last_login_at = Time.now and u.save if u.respond_to?(:last_login_at)
+          if u.respond_to?(:last_login_at) || u.respond_to?(:logins_count)
+            u.last_login_at = Time.now if u.respond_to?(:last_login_at)
+            u.logins_count = (u.logins_count.to_i + 1) if u.respond_to?(:logins_count)
+            u.save
+          end
           u
         else
           nil
@@ -68,10 +86,12 @@ module Hobo
       self.class.encrypt(password, salt)
     end
 
+    # Check if the encrypted passwords match
     def authenticated?(password)
       crypted_password == encrypt(password)
     end
 
+    # Do we still need to remember the login token, or has it expired?
     def remember_token?
       remember_token_expires_at && Time.now.utc < remember_token_expires_at
     end
@@ -83,6 +103,7 @@ module Hobo
       save(false)
     end
 
+    # Expire the login token, resulting in a forced login next time.
     def forget_me
       self.remember_token_expires_at = nil
       self.remember_token            = nil
@@ -90,13 +111,14 @@ module Hobo
     end
 
     protected
-    # before filter
+    # Before filter that encrypts the password before having it stored in the database.
     def encrypt_password
       return if password.blank?
       self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{login}--") if new_record?
       self.crypted_password = encrypt(password)
     end
 
+    # Is a password required for login? (or do we have an empty password?
     def password_required?
       (crypted_password.blank? && password != nil) || !password.blank?
     end

data/hobo_files/plugin/lib/hobo/authentication_support.rb

@@ -77,7 +77,7 @@ module Hobo
     # Redirect to the URI stored by the most recent store_location call or
     # to the passed default.
     def redirect_back_or_default(default)
-      session[:return_to] ? redirect_to_url(session[:return_to]) : redirect_to(default)
+      session[:return_to] ? redirect_to(session[:return_to]) : redirect_to(default)
       session[:return_to] = nil
     end
 
@@ -85,6 +85,7 @@ module Hobo
     # cookie and log the user back in if apropriate
     def login_from_cookie
       return unless cookies[:auth_token] && !logged_in?
+      
       user = Hobo.user_model.find_by_remember_token(cookies[:auth_token])
       if user && user.remember_token?
         user.remember_me

data/hobo_files/plugin/lib/hobo/controller.rb

@@ -2,19 +2,35 @@ module Hobo
 
   module Controller
 
-    include ControllerHelpers
-    
     include AuthenticationSupport
-
+    
     def self.included(base)
       if base.is_a?(Class)
-        Hobo::ControllerHelpers.public_instance_methods.each {|m| base.hide_action(m)}
-        base.class_eval do
-          alias_method_chain :redirect_to, :object_url
-        end
+        included_in_class(base)
+      end
+    end
+    
+    def self.included_in_class(klass)
+      klass.extend(ClassMethods)
+      klass.class_eval do
+        alias_method_chain :redirect_to, :object_url
+        @included_taglibs = []
       end
+      Hobo::HoboHelper.add_to_controller(klass)
     end
 
+    module ClassMethods
+
+      attr_reader :included_taglibs
+
+      def include_taglib(src, options={})
+        @included_taglibs << if options[:from_plugin]
+                               'plugins/' + options[:from_plugin] + '/taglibs/' + src
+                             else
+                               src
+                             end
+      end
+    end
 
     protected
     
@@ -91,17 +107,24 @@ module Hobo
     end
 
 
-    def render_tag(tag, options={})
+    def render_tag(tag, options={}, render_options={})
       add_variables_to_assigns
-      render :text => Hobo::Dryml.render_tag(@template, tag, options), :layout => false
+      render({:text => Hobo::Dryml.render_tag(@template, tag, options),
+               :layout => false }.merge(render_options))
     end
 
 
     def render_tags(objects, tag, options={})
+      for_type = options.delete(:for_type)
       add_variables_to_assigns
       dryml_renderer = Hobo::Dryml.empty_page_renderer(@template)
-      render :text => objects.map {|o| dryml_renderer.send(tag, options.merge(:obj => o))}.join +
-                      dryml_renderer.part_contexts_js
+      
+      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))
+      end.join
+      
+      render :text => results + dryml_renderer.part_contexts_js
     end
 
 
@@ -110,7 +133,7 @@ module Hobo
       if results.empty?
         render :text => "<p>Your search returned no matches.</p>"
       else
-        render_tags(results, "tag_for_object", :name => "search_result")
+        render_tags(results, :card, :for_type => true)
       end
     end
 

data/hobo_files/plugin/lib/hobo/define_tags.rb

@@ -25,7 +25,7 @@ module Hobo
         @hobo_tag_blocks["#{name}_predicate"] = pred if pred
 
         safe_name = Dryml.unreserve(name)
-        locals = attrs.map{|a| Hobo::Dryml.unreserve(a)} + ["options"]
+        locals = attrs.map{|a| Hobo::Dryml.unreserve(a)} + %w{options inner_tag_options}
         
         def_line = if pred
                      "defp :#{safe_name}, @hobo_tag_blocks['#{name}_predicate'] do |options, block|"
@@ -36,17 +36,17 @@ module Hobo
                      "def #{safe_name}(options={}, &block)"
                    end
 
-        src = <<-END
+        class_eval(<<-END, __FILE__, __LINE__+1)
           #{def_line}
             _tag_context(options, block) do |tagbody|
-              locals = _tag_locals(options, #{attrs.inspect}, [])
+              locals = _tag_locals(options, #{attrs.inspect})
               locals_hash = { :tagbody => tagbody };
               #{locals.inspect}.each_with_index{|a, i| locals_hash[a] = locals[i]}
               Hobo::ProcBinding.new(self, locals_hash).instance_eval(&#{self.name}.hobo_tag_blocks['#{name}'])
             end
           end
         END
-        class_eval src, __FILE__, __LINE__
+        
       end
     
     end

data/hobo_files/plugin/lib/hobo/dryml.rb

@@ -1,6 +1,16 @@
 module Hobo::Dryml
+  
+  class DrymlSyntaxError < RuntimeError; end
 
-  class DrymlException < Exception; 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
   
   class AttributeExtensionString < String;
     def drop_prefix; self[2..-1]; end
@@ -12,6 +22,9 @@ module Hobo::Dryml
 
   EMPTY_PAGE = "[tag-page]"
 
+  APPLICATION_TAGLIB = "taglibs/application"
+  CORE_TAGLIB = "plugins/hobo/tags/core"
+
   @renderer_classes = {}
 
   class << self
@@ -41,8 +54,15 @@ module Hobo::Dryml
       end
 
       prepare_view!(view)
+      included_taglibs = if view.controller.class.respond_to? :included_taglibs
+                           view.controller.class.included_taglibs
+                         else
+                           []
+                         end
+
       if page == EMPTY_PAGE
-        @tag_page_renderer_class =  make_renderer_class("", EMPTY_PAGE, local_names, [ApplicationHelper]) if
+        @tag_page_renderer_class =  make_renderer_class("", EMPTY_PAGE, local_names,
+                                                        [Hobo::HoboHelper, ApplicationHelper], included_taglibs) if
           @tag_page_renderer_class.nil?
         @tag_page_renderer_class.new(page, view)
       else
@@ -56,7 +76,7 @@ module Hobo::Dryml
             (local_names - renderer_class.compiled_local_names).any? or # any new local names?
             renderer_class.load_time < src_file.mtime)                  # cache out of date?
           renderer_class = make_renderer_class(src_file.read, template_path, local_names,
-                                               default_imports_for_view(view))
+                                               default_imports_for_view(view), included_taglibs)
           renderer_class.load_time = src_file.mtime
           @renderer_classes[page] = renderer_class
         end
@@ -82,26 +102,30 @@ module Hobo::Dryml
 
     
     def default_imports_for_view(view)
-      [ApplicationHelper,
-       view.controller.class.name.sub(/Controller$/, "Helper").constantize]
+      imports = [Hobo::HoboHelper, ApplicationHelper]
+      controller_helper = view.controller.class.name.sub(/Controller$/, "Helper")
+      imports << controller_helper.constantize if Object.const_defined? controller_helper
+      imports
     end
 
     
-    def make_renderer_class(template_src, template_path, locals, imports)
+    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)
+      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)
+    def compile_renderer_class(renderer_class, template_src, template_path, locals, imports, included_taglibs=[])
       template = 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)
+      template.compile(all_local_names, taglibs)
     end
 
     
@@ -114,48 +138,6 @@ module Hobo::Dryml
       end
     end
     
-    
-    def merge_tag_options(to, from)
-      res = to.merge({})
-      from.each_pair do |option, value|
-        res[option] = if value.is_a?(AttributeExtensionString) and to.has_key?(option)
-                        "#{to[option]} #{value.drop_prefix}"
-                      else
-                        value
-                      end
-      end
-      res
-    end
-
-    
-    def hashify_options(options, merge_into=nil)
-      result = merge_into || options
-      
-      options.each_pair do |key, val|
-        if key.is_a? Array
-          result.delete(key)
-          k = key.first
-          
-          if key.length == 2 and key.last.is_a? Fixnum
-            hashify_options(val) if val.is_a?(Hash)
-            result[k] ||= []
-            result[k][key.last] = val
-          else
-            existing = options[k]
-            v = if key.length == 1
-                  val.is_a?(Hash) ? hashify_options(val, existing) : val
-                else
-                  hashify_options({key[1..-1] => val}, existing)
-                end
-            result[k] = v
-          end          
-        else
-          hashify_options(val) if val.is_a?(Hash)
-        end
-      end
-      result
-    end
-
   end
 
 end

data/hobo_files/plugin/lib/hobo/dryml/dryml_builder.rb

@@ -1,14 +1,14 @@
 module Hobo::Dryml
   
   class DRYMLBuilder
-    
-    APPLICATION_TAGLIB = "hobolib/application"
-    CORE_TAGLIB = "plugins/hobo/tags/core"
 
     def initialize(template_path)
+      @template_path = template_path
       @build_instructions = Array.new
-      @template_path      = template_path
+      @part_names = []
     end
+    
+    attr_reader :template_path
 
 
     def set_environment(environment)
@@ -22,12 +22,20 @@ module Hobo::Dryml
 
 
     def clear_instructions
+      @part_names.clear
       @build_instructions.clear
     end
 
 
-    def add_build_instruction(params)
-      @build_instructions << params
+    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(:part, :src => src, :line_num => line_num)
+      @part_names << name
     end
 
 
@@ -36,47 +44,57 @@ module Hobo::Dryml
     end
 
 
-    def get_render_page_source(src, local_names)
+    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 +
-           "; end + part_contexts_js; end")
+           "; _erbout; end + part_contexts_js; end")
+    end
+    
+    
+    def erb_process(erb_src)
+      # 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)]
     end
 
 
     def build(local_names, auto_taglibs)
-      if auto_taglibs
-        import_taglib(CORE_TAGLIB)
-        import_taglib(APPLICATION_TAGLIB)
-        Hobo::MappingTags.apply_standard_mappings(@environment)
-      end
+
+      auto_taglibs.each{|t| import_taglib(t)}
     
-      @build_instructions.each do |build_instruction|
-        case build_instruction[:type]
-        when :def, :part
-          @environment.class_eval(build_instruction[:src], @template_path, build_instruction[:line_num])
+      @build_instructions.each do |instruction|
+        name = instruction[:name]
+        case instruction[:type]
+        when :def
+          src = erb_process(instruction[:src])
+          @environment.class_eval(src, template_path, instruction[:line_num])
+          
+        when :part
+          @environment.class_eval(erb_process(instruction[:src]), template_path, instruction[:line_num])
           
         when :render_page
-          method_src = get_render_page_source(build_instruction[:src], local_names)
+          method_src = render_page_source(erb_process(instruction[:src]), local_names)
           @environment.compiled_local_names = local_names
-          @environment.class_eval(method_src, @template_path, build_instruction[:line_num])
+          @environment.class_eval(method_src, template_path, instruction[:line_num])
           
-        when :taglib
-          import_taglib(build_instruction[:name], build_instruction[:as])
+        when :include
+          import_taglib(name, instruction[:as])
           
         when :module
-          import_module(build_instruction[:name].constantize, build_instruction[:as])
+          import_module(name.constantize, instruction[:as])
           
         when :set_theme
-          set_theme(build_instruction[:name])
+          set_theme(name)
           
         when :alias_method
-          @environment.send(:alias_method, build_instruction[:new], build_instruction[:old])
+          @environment.send(:alias_method, instruction[:new], instruction[:old])
           
         else
-          raise HoboError.new("DRYML: Unknown build instruction type found when building #{@template_path}")
+          raise RuntimeError.new("DRYML: Unknown build instruction :#{instruction[:type]}, building #{template_path}")
         end
       end
       @last_build_time = Time.now
@@ -89,7 +107,7 @@ module Hobo::Dryml
              elsif path.include?("/")
                "app/views/#{path}"
              else
-               template_dir = File.dirname(@template_path)
+               template_dir = File.dirname(template_path)
                "#{template_dir}/#{path}"
              end
        base + ".dryml"
@@ -98,7 +116,7 @@ module Hobo::Dryml
 
     def import_taglib(src_path, as=nil)
       path = expand_template_path(src_path)
-      unless @template_path == path
+      unless template_path == path
         taglib = Taglib.get(RAILS_ROOT + (path.starts_with?("/") ? path : "/" + path))
         taglib.import_into(@environment, as)
       end
@@ -106,7 +124,7 @@ module Hobo::Dryml
 
 
     def import_module(mod, as=nil)
-      raise NotImplementedError.new if as
+      raise NotImplementedError if as
       @environment.send(:include, mod)
     end
   
@@ -114,12 +132,7 @@ module Hobo::Dryml
     def set_theme(name)
       if Hobo.current_theme.nil? or Hobo.current_theme == name
         Hobo.current_theme = name
-        import_taglib("hobolib/themes/#{name}/application")
-        mapping_module = "#{name}_mapping"
-        if File.exists?(path = RAILS_ROOT + "/app/views/hobolib/themes/#{mapping_module}.rb")
-          load(path)
-          Hobo::MappingTags.apply_mappings(@environment)
-        end
+        import_taglib("taglibs/themes/#{name}/application")
       end
     end
   end