hobo 0.6 → 0.6.1

data/hobo_files/plugin/lib/extensions.rb

@@ -70,13 +70,40 @@ class Module
 end
 
 module Kernel
-  
+
   def extract_options_from_args!(args) #:nodoc:
     args.last.is_a?(Hash) ? args.pop : {}
   end
   
+  def it() It.new end
+  alias its it
+
+end
+
+
+class It
+
+  undef_method(*(instance_methods - %w*__id__ __send__*))
+
+  def initialize
+    @methods = []
+  end
+
+  def method_missing(*args, &block)
+    @methods << [args, block] unless args == [:respond_to?, :to_proc]
+    self
+  end
+
+  def to_proc
+    lambda do |obj|
+      @methods.inject(obj) do |current,(args,block)|
+        current.send(*args, &block)
+      end
+    end
+  end
 end
 
+
 class Object
 
   def in?(array)
@@ -112,30 +139,6 @@ end
 
 module Enumerable
 
-  def omap(method = nil, &b)
-    if method
-      map(&method)
-    else
-      map {|x| x.instance_eval(&b)}
-    end
-  end
-
-  def oselect(method = nil, &b)
-    if method
-      select(&method)
-    else
-      select {|x| x.instance_eval(&b)}
-    end
-  end
-
-  def ofind(method=nil, &b)
-    if method
-      find(&method)
-    else
-      find {|x| x.instance_eval(&b)}
-    end
-  end
-
   def search(not_found=nil)
     each do |x|
       val = yield(x)
@@ -144,22 +147,6 @@ module Enumerable
     not_found
   end
 
-  def oany?(method=nil, &b)
-    if method
-      any?(&method)
-    else
-      any? {|x| x.instance_eval(&b)}
-    end
-  end
-
-  def oall?(method=nil, &b)
-    if method
-      all?(&method)
-    else
-      all? {|x| x.instance_eval(&b)}
-    end
-  end
-
   def every(proc)
     map(&proc)
   end

data/hobo_files/plugin/lib/hobo.rb

@@ -16,7 +16,7 @@ module Hobo
       field_types.index(type)
     end
     
-    def type_name(type)
+    def type_id(type)
       symbolic_type_name(type) || type.name.underscore.gsub("/", "__")
     end
 
@@ -52,7 +52,7 @@ module Hobo
         end
         @models_loaded = true
       end
-      @models.omap{constantize}
+      @models.every(:constantize)
     end
 
     
@@ -64,21 +64,25 @@ module Hobo
     def object_from_dom_id(dom_id)
       return nil if dom_id == 'nil'
 
-      _, name, id, attr = *dom_id.match(/^([a-z_]+)_([0-9]+(?:_[0-9]+)*)(_[a-z_]+)?$/)
+      _, name, id, attr = *dom_id.match(/^([a-z_]+)(?:_([0-9]+(?:_[0-9]+)*))?(?:_([a-z_]+))?$/)
       raise ArgumentError.new("invalid model-reference in dom id") unless name
       if name
         model_class = name.camelize.constantize rescue (raise ArgumentError.new("no such class in dom-id"))
         return nil unless model_class
-        attr = attr[1..-1] if attr
-        obj = if false and attr and model_class.reflections[attr.to_sym].klass.superclass == ActiveRecord::Base
-                # DISABLED - Eager loading is broken - doesn't support ordering
-                # http://dev.rubyonrails.org/ticket/3438
-                # Don't do this for STI subclasses - it breaks!
-                model_class.find(id, :include => attr)
-              else
-                model_class.find(id)
-              end
-        attr ? obj.send(attr) : obj
+        
+        if id
+          obj = if false and attr and model_class.reflections[attr.to_sym].klass.superclass == ActiveRecord::Base
+                  # DISABLED - Eager loading is broken - doesn't support ordering
+                  # http://dev.rubyonrails.org/ticket/3438
+                  # Don't do this for STI subclasses - it breaks!
+                  model_class.find(id, :include => attr)
+                else
+                  model_class.find(id)
+                end
+          attr ? obj.send(attr) : obj
+        else
+          model_class
+        end
       end
     end
 
@@ -91,6 +95,8 @@ module Hobo
       if obj.is_a?(Array) and obj.respond_to?(:proxy_owner)
         attr = obj.proxy_reflection.name
         obj = obj.proxy_owner
+      elsif obj.is_a?(Class)
+        return type_id(obj)
       elsif !obj.respond_to?(:typed_id)
         if attr
           return dom_id(get_field(obj, attr))
@@ -133,7 +139,13 @@ module Hobo
     end
 
     def add_routes(map)
-      ActiveRecord::Base.connection.reconnect! unless ActiveRecord::Base.connection.active?
+      begin 
+        ActiveRecord::Base.connection.reconnect! unless ActiveRecord::Base.connection.active?
+      rescue
+        # No database, no routes
+        return
+      end
+
       require "#{RAILS_ROOT}/app/controllers/application" unless Object.const_defined? :ApplicationController
       require "#{RAILS_ROOT}/app/assemble.rb" if File.exists? "#{RAILS_ROOT}/app/assemble.rb"
       
@@ -150,9 +162,8 @@ module Hobo
             map.connect "#{web_name}/:id", :controller => web_name, :action => 'show'
 
           elsif controller < Hobo::ModelController
-            
             map.resources web_name, :collection => { :completions => :get }
-            
+
             for collection in controller.collections
               new_method = Hobo.simple_has_many_association?(model.reflections[collection])
               Hobo.add_collection_routes(map, web_name, collection, new_method)
@@ -173,6 +184,15 @@ module Hobo
                               :action => view.to_s,
                               :conditions => { :method => :get })
             end
+            
+            if controller < Hobo::UserController
+              map.named_route("#{web_name.singularize}_login", "#{web_name.singularize}_login",
+                              :controller => web_name, :action => 'login')
+              map.named_route("#{web_name.singularize}_logout", "#{web_name.singularize}_logout",
+                              :controller => web_name, :action => 'logout')
+              map.named_route("#{web_name.singularize}_signup", "#{web_name.singularize}_signup",
+                              :controller => web_name, :action => 'signup')
+            end
           end
         end
       end
@@ -337,7 +357,7 @@ module Hobo
                                 else
                                     File.join(File.dirname(__FILE__), "hobo/static_tags")
                                 end
-                         File.readlines(path).omap{chop} 
+                         File.readlines(path).every(:chop)
                        end
     end
     

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

@@ -36,12 +36,17 @@ module Hobo
     #
     #   skip_before_filter :login_required
     #
-    def login_required
-      if current_user.guest?
+    def login_required(user_model=nil)
+      if current_user.guest? 
+        auth_model = user_model || UserController.user_models.first
         username, passwd = get_auth_data
-        self.current_user = Hobo.user_model.authenticate(username, passwd) || :false if username && passwd
+        self.current_user = auth_model.authenticate(username, passwd) || :false if username && passwd && auth_model
+      end
+      if logged_in? && authorized? && (user_model.nil? || current_user.is_a?(user_model))
+        true
+      else
+        access_denied
       end
-      logged_in? && authorized? ? true : access_denied
     end
 
     # Redirect as appropriate when an access request fails.
@@ -84,16 +89,22 @@ 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 cookies[:auth_token] && !logged_in?
+      return unless (token = cookies[:auth_token]) && !logged_in?
       
-      user = Hobo.user_model.find_by_remember_token(cookies[:auth_token])
+      user_model = token[:user_model].constantize
+      user = user_model.find_by_remember_token(token)
       if user && user.remember_token?
         user.remember_me
-        self.current_user = user
-        cookies[:auth_token] = { :value => self.current_user.remember_token ,
-                                 :expires => self.current_user.remember_token_expires_at }
+        current_user = user
+        create_auth_cookie
       end
     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 }
+    end
 
     private
     @@http_auth_headers = %w(X-HTTP_AUTHORIZATION HTTP_AUTHORIZATION Authorization)
@@ -101,7 +112,11 @@ module Hobo
     def get_auth_data
       auth_key  = @@http_auth_headers.detect { |h| request.env.has_key?(h) }
       auth_data = request.env[auth_key].to_s.split unless auth_key.blank?
-      return auth_data && auth_data[0] == 'Basic' ? Base64.decode64(auth_data[1]).split(':')[0..1] : [nil, nil]
+      username, pw = if auth_data && auth_data[0] == 'Basic'
+                       Base64.decode64(auth_data[1]).split(':')[0..1]
+                     else
+                       [nil, nil]
+                     end
     end
 
   end

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

@@ -12,7 +12,7 @@ module Hobo
       end
         
       def compose(*models)
-        @models = models.omap{to_s.camelize}
+        @models = models.map &it.to_s.camelize
         attr_reader *models
         CompositeModel.composites ||= {}
         CompositeModel.composites[@models.sort] = self.name
@@ -57,7 +57,7 @@ module Hobo
     
     def id
       objects = self.class.models.map {|m| instance_variable_get("@#{m.underscore}")}
-      objects.omap{id}.join("_")
+      objects.every(:id).join("_")
     end
       
   end

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

@@ -56,7 +56,6 @@ module Hobo
 
 
     def ajax_update_response(this, part_page, render_specs, results={})
-      before_ajax if respond_to? :before_ajax
       add_variables_to_assigns
       renderer = Hobo::Dryml.page_renderer(@template, [], part_page) if part_page
 
@@ -64,45 +63,20 @@ module Hobo
         page << "var _update = typeof Hobo == 'undefined' ? Element.update : Hobo.updateElement;"
         for spec in render_specs
           function = spec[:function] || "_update"
-
-          if spec[:as] or spec[:part]
-            obj = if spec[:object] == "this" or spec[:object].blank?
-                    this
-                  elsif spec[:object] == "nil"
-                    nil
-                  else
-                    Hobo.object_from_dom_id(spec[:object])
-                  end
-
-            if spec[:as]
-              part_content = render(:partial => (Hobo::ModelController.find_partial(obj.class, spec[:as])),
-                                 :locals => { :this => obj })
-              page.call(function, spec[:id], part_content)
-              
-            elsif spec[:part]
-              dom_id = spec[:id] || spec[:part]
-              part_content = renderer.call_part(dom_id, spec[:part], obj)
-              page.call(function, dom_id, part_content)
-            end
-            
+          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)
+            page.call(function, dom_id, part_content)
           elsif spec[:result]
             result = results[spec[:result].to_sym]
             page.call(function, spec[:id], result)
-            
           else
             # spec didn't specify any action :-/
           end
         end
-        if renderer
-          renderer.part_contexts.each_pair do |dom_id, p|
-            part_id, model_id = p
-            page.assign "hoboParts.#{dom_id}", [part_id, model_id]
-            
-            # not sure why this isn't happending automatically
-            # but it's messing up ARTS, so chuck a newline in
-            page << "\n"
-          end
-        end
+        page << renderer.part_contexts_storage if renderer
       end
     end
 
@@ -140,7 +114,7 @@ module Hobo
 
     # Store the given user in the session.
     def current_user=(new_user)
-      session[:user] = (new_user.nil? || new_user.is_a?(Symbol)) ? nil : new_user.id
+      session[:user] = (new_user.nil? || new_user.is_a?(Symbol)) ? nil : new_user.typed_id
       @current_user = new_user
     end
 

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

@@ -50,7 +50,7 @@ module Hobo::Dryml
       ("def render_page(__page_this__, __local_assigns__); " +
             "#{locals} new_object_context(__page_this__) do " +
             src +
-           "; _erbout; end + part_contexts_js; end")
+           "; _erbout; end + part_contexts_storage_tag; end")
     end
     
     

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

@@ -0,0 +1,103 @@
+module Hobo
+  
+  module Dryml
+    
+    # Raised when the part context fails its integrity check.
+    class PartContext
+      
+      class TamperedWithPartContext < StandardError; end
+    
+      class Id < String; end
+      
+      class << self
+        attr_accessor :secret, :digest
+      end
+      self.digest = 'SHA1'
+      
+      
+      def self.client_side_storage(contexts, session)
+        return "" if contexts.empty?
+
+        contexts.map do |dom_id, context|
+          code = context.marshal(session).split("\n").map{|line| "'#{line}\\n'"}.join(" +\n    ")
+          "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)
+        if x.is_a?(ActiveRecord::Base) && x.respond_to?(:typed_id)
+          Id.new(x.typed_id)
+        else
+          x
+        end
+      end
+      
+      
+      def marshal(session)
+        context = [@part_name, @this_id, @locals]
+        puts "STORE: " + context.inspect
+        data = Base64.encode64(Marshal.dump(context)).strip
+        "#{data}--#{self.class.generate_digest(data, session)}"
+      end
+        
+
+      class << self
+        
+        # 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
+        
+        
+        # Unmarshal part context to a hash and verify its integrity.
+        def unmarshal(client_store, this, session)
+          data, digest = CGI.unescape(client_store).strip.split('--')
+
+          raise TamperedWithPartContext unless digest == generate_digest(data, session)
+
+          part_name, this_id, locals = Marshal.load(Base64.decode64(data))
+          puts "RESTORE: " + [part_name, this_id, locals].inspect
+
+          x = [part_name, restore_part_this(this_id, this), restore_locals(locals)]
+          puts this_id, x.inspect
+          x
+        end
+      
+        def restore_part_this(this_id, this)
+          if this_id == "this" or this_id.blank?
+            this
+          elsif this_id == "nil"
+            nil
+          else
+            Hobo.object_from_dom_id(this_id)
+          end          
+        end
+        
+        
+        def restore_locals(locals)
+          locals.map do |l|
+            if l.is_a?(Id)
+              Hobo.object_from_dom_id(l)
+            else
+              l
+            end
+          end
+        end
+        
+      end
+      
+    end
+    
+  end 
+  
+end