hobo 1.1.0 → 1.3.0.RC

data/lib/generators/hobo/user_model/user_model_generator.rb

@@ -0,0 +1,23 @@
+require 'generators/hobo_support/model'
+module Hobo
+  class UserModelGenerator < Rails::Generators::NamedBase
+    source_root File.expand_path('../templates', __FILE__)
+
+    # overrides the default
+    argument :name, :type => :string, :default => 'user', :optional => true
+
+    include Generators::HoboSupport::Model
+    include Generators::Hobo::InviteOnly
+    include Generators::Hobo::ActivationEmail
+
+    def self.banner
+      "rails generate hobo:user_model [NAME=user] [options]"
+    end
+
+    class_option :admin_subsite_name,
+                 :type => :string,
+                 :desc => "Admin Subsite Name",
+                 :default => 'admin'
+
+  end
+end

data/lib/generators/hobo/user_resource/user_resource_generator.rb

@@ -0,0 +1,27 @@
+module Hobo
+  class UserResourceGenerator < Rails::Generators::NamedBase
+
+    # overrides the default
+    argument :name, :type => :string, :default => 'user', :optional => true
+
+    include Generators::Hobo::InviteOnly
+    include Generators::Hobo::ActivationEmail
+
+    def self.banner
+      "rails generate hobo:user_resource [NAME=user] [options]"
+    end
+
+    def generate_hobo_model
+      invoke 'hobo:user_model', [name.singularize], options
+    end
+
+    def generate_hobo_mailer
+      invoke 'hobo:user_mailer', [name.singularize], options
+    end
+
+    def generate_hobo_user_controller
+      invoke 'hobo:user_controller', [name.pluralize], options
+    end
+
+  end
+end

data/lib/hobo.rb

@@ -1,62 +1,40 @@
-# gem dependencies
-require 'hobosupport'
-require 'hobofields'
-begin
-  gem 'will_paginate', '~> 2'
-  require 'will_paginate'
-  require 'will_paginate/finder'
-rescue MissingSourceFile
-  # OK, Hobo won't do pagination then
-end
-
-if ActiveSupport::Dependencies.respond_to?(:autoload_paths)
-  ActiveSupport::Dependencies.autoload_paths |= [ File.dirname(__FILE__)]
-else
-  ActiveSupport::Dependencies.load_paths |= [ File.dirname(__FILE__)]
-end
+require 'hobo_support'
+require 'hobo_fields'
+require 'dryml'
+require 'will_paginate'
+require 'hobo/extensions/enumerable'
+require 'hobo/extensions/array'
 
-# Hobo can be installed in /vendor/hobo, /vendor/plugins/hobo, vendor/plugins/hobo/hobo, etc.
-::HOBO_ROOT = File.expand_path(File.dirname(__FILE__) + "/..")
+ActiveSupport::Dependencies.autoload_paths |= [File.dirname(__FILE__)]
 
-class HoboError < RuntimeError; end
 
 module Hobo
 
-  VERSION = "1.1.0"
+  VERSION = File.read(File.expand_path('../../VERSION', __FILE__)).strip
+  @@root = Pathname.new File.expand_path('../..', __FILE__)
+  def self.root; @@root; end
 
+  class Error < RuntimeError; end
   class PermissionDeniedError < RuntimeError; end
+  class UndefinedAccessError < RuntimeError; end
+  class I18nError < RuntimeError; end
 
+  # Empty class to represent the boolean type.
+  class Boolean; end
   class RawJs < String; end
 
-  @models = []
-
   class << self
 
-
-    attr_accessor :current_theme
-    attr_writer :developer_features
-
-
-    def developer_features?
-      @developer_features
-    end
-
+    attr_accessor :current_theme, :engines
 
     def raw_js(s)
       RawJs.new(s)
     end
 
-
-    def find_by_search(query, search_targets=nil)
-      search_targets ||=
-        begin
-          # FIXME: This should interrogate the model-router directly, there's no need to enumerate models
-          # By default, search all models, but filter out...
-          Hobo::Model.all_models.select do |m|
-            ModelRouter.linkable?(m, :show) &&  # ...non-linkables
-              m.search_columns.any?             # and models with no search-columns
-          end
-        end
+    def find_by_search(query, search_targets=[])
+      if search_targets.empty?
+       search_targets = Hobo::Routes.models_with(:show).select {|m| m.search_columns.any? }
+      end
 
       query_words = ActiveRecord::Base.connection.quote_string(query).split
 
@@ -71,16 +49,11 @@ module Hobo
         end
         conditions = conditions.join(" and ")
 
-        results = search_target.find(:all, :conditions => [conditions, *parameters])
+        results = search_target.where(conditions, *parameters)
         [search_target.name, results] unless results.empty?
       end
     end
 
-    def add_routes(m)
-      Hobo::ModelRouter.add_routes(m)
-    end
-
-
     def simple_has_many_association?(array_or_reflection)
       refl = array_or_reflection.respond_to?(:proxy_reflection) ? array_or_reflection.proxy_reflection : array_or_reflection
       return false unless refl.is_a?(ActiveRecord::Reflection::AssociationReflection)
@@ -91,96 +64,23 @@ module Hobo
 
     def subsites
       # Any directory inside app/controllers defines a subsite
-      @subsites ||= Dir["#{RAILS_ROOT}/app/controllers/*"].map { |f| File.basename(f) if File.directory?(f) }.compact
-    end
-    
-    public
-
-    def enable
-      require 'action_view_extensions/helpers/tag_helper'
-
-      # Modules that must *not* be auto-reloaded by activesupport
-      # (explicitly requiring them means they're never unloaded)
-      require 'hobo/model_router'
-      require 'hobo/undefined'
-      require 'hobo/user'
-      require 'dryml'
-      require 'dryml/template'
-      require 'dryml/dryml_generator'
-
-      Hobo::Model.enable
-      Dryml.enable(["#{HOBO_ROOT}/rapid_generators"], "#{RAILS_ROOT}/app/views/taglibs/auto")
-      Hobo::Permissions.enable
-      Hobo::ViewHints.enable
-      
-      Hobo.developer_features = RAILS_ENV.in?(["development", "test"]) if Hobo.developer_features?.nil?
-
-      require 'hobo/dev_controller' if RAILS_ENV == Hobo.developer_features?
-
-      ActionController::Base.send(:include, Hobo::ControllerExtensions)
-
-      HoboFields.never_wrap(Hobo::Undefined) if defined? HoboFields
-
-      if ActiveSupport::Dependencies.respond_to?(:autoload_paths)
-        ActiveSupport::Dependencies.autoload_paths |= [ "#{RAILS_ROOT}/app/viewhints" ]
-      else
-        ActiveSupport::Dependencies.load_paths |= [ "#{RAILS_ROOT}/app/viewhints" ]
-      end
+      app_dirs = ["#{Rails.root}/app"] + Hobo.engines.map { |e| "#{e}/app" }
+      @subsites ||= app_dirs.map do |app|
+                      Dir["#{app}/controllers/*"].map do |f|
+                        File.basename(f) if File.directory?(f)
+                      end.compact
+                    end.flatten
     end
 
   end
 
-  ControllerExtensions = classy_module do
-    def self.hobo_user_controller(model=nil)
-      @model = model
-      include Hobo::ModelController
-      include Hobo::UserController
-    end
-
-    def self.hobo_model_controller(model=nil)
-      @model = model
-      include Hobo::ModelController
-    end
-
-    def self.hobo_controller
-      include Hobo::Controller
-    end
-
-  end
-
-  # Empty class to represent the boolean type.
-  class Boolean; end
+  self.engines = []
 
 end
 
+require 'hobo/engine'
 
-# Add support for type metadata to arrays
-class ::Array
 
-  attr_accessor :member_class, :origin, :origin_attribute
 
-  def to_url_path
-    base_path = origin_object.try.to_url_path
-    "#{base_path}/#{origin_attribute}" unless base_path.blank?
-  end
-
-  def typed_id
-    origin and origin_id = origin.try.typed_id and "#{origin_id}:#{origin_attribute}"
-  end
-
-end
 
 
-module ::Enumerable
-  def group_by_with_metadata(&block)
-    r=group_by_without_metadata(&block)
-    r.each do |k,v|
-      v.origin = origin
-      v.origin_attribute = origin_attribute
-      v.member_class = member_class
-    end
-    r
-  end
-  alias_method_chain :group_by, :metadata
-end
-

data/lib/hobo/controller.rb

@@ -14,31 +14,22 @@ module Hobo
 
       def included_in_class(klass)
         klass.extend(ClassMethods)
-        klass.send(:include, Hobo::Translations)
+        klass.send(:include, Hobo::Helper::Translations)
         klass.class_eval do
-          before_filter :login_from_cookie 
+          before_filter :login_from_cookie
           alias_method_chain :redirect_to, :object_url
-          around_filter do |controller, action|
-            Thread.current['Hobo.current_controller'] = controller
-            action.call
-            Thread.current['Hobo.current_controller'] = nil  # should avoid memory-leakage
+          private
+          def set_mailer_default_url_options
+            unless Rails.application.config.action_mailer.default_url_options
+              Rails.application.config.action_mailer.default_url_options = { :host => request.host }
+              Rails.application.config.action_mailer.default_url_options[:port] = request.port unless request.port == 80
+            end
           end
+          before_filter :set_mailer_default_url_options
           @included_taglibs = []
-          rescue_from ActionController::RoutingError, :with => :not_found
+          rescue_from ActionController::RoutingError, :with => :not_found unless Rails.env.development?
         end
-        Hobo::HoboHelper.add_to_controller(klass)
-      end
-
-      def controller_and_view_for(page_path)
-        page_path.match(/(.*)\/([^\/]+)/)[1..2]
-      end
-
-      def request_host
-        Thread.current['Hobo.current_controller'].request.host_with_port
-      end
-
-      def app_name
-        Thread.current['Hobo.current_controller'].send(:call_tag, :app_name)
+        Hobo::Helper.add_to_controller(klass)
       end
 
     end
@@ -67,10 +58,9 @@ module Hobo
 
     def hobo_ajax_response(*args)
       results = args.extract_options!
-      page_path = params[:page_path]
       r = params[:render]
       if r
-        ajax_update_response(page_path, r.values, results)
+        ajax_update_response(r.values, results)
         true
       else
         false
@@ -78,9 +68,13 @@ module Hobo
     end
 
 
-    def ajax_update_response(page_path, render_specs, results={}, options={})
-      @template.send(:_evaluate_assigns_and_ivars)
-      renderer = Dryml.page_renderer(@template, [], page_path) if page_path
+    def ajax_update_response(render_specs, results={}, options={})
+      controller, action = controller_action_from_page_path
+      identifier = view_context.view_paths.find( action,
+                                                 controller,
+                                                 false,
+                                                 view_context.lookup_context.instance_variable_get('@details')).identifier
+      renderer = Dryml.page_renderer(view_context, identifier, [], controller)
 
       render :update do |page|
         page << (options[:preamble] || "var _update = typeof Hobo == 'undefined' ? Element.update : Hobo.updateElement;")
@@ -104,6 +98,12 @@ module Hobo
     end
 
 
+    # dryml does not use layouts
+    def action_has_layout?
+      false
+    end
+
+
     def dryml_context
       @this
     end
@@ -120,25 +120,22 @@ module Hobo
 
       render :text => results + tag_renderer.part_contexts_storage
     end
-    
-    
+
+
     def tag_renderer
-      @tag_renderer ||= begin
-        @template.send(:_evaluate_assigns_and_ivars)
-        Dryml.empty_page_renderer(@template)
-      end
-    end    
-    
-    
+      @tag_renderer ||= Dryml.empty_page_renderer(view_context)
+    end
+
+
     def call_tag(name, options={})
       tag_renderer.send(name, options)
     end
-    
+
     def site_search(query)
       results_hash = Hobo.find_by_search(query)
       all_results = results_hash.values.flatten.select { |r| r.viewable_by?(current_user) }
       if all_results.empty?
-        render :text => "<p>"+ ht(:"hobo.live_search.no_results", :default=>["Your search returned no matches."]) + "</p>"
+        render :text => "<p>"+ t("hobo.live_search.no_results", :default=>["Your search returned no matches."]) + "</p>"
       else
         # TODO: call one tag that renders all the search results with headings for each model
         render_tags(all_results, :search_card, :for_type => true)
@@ -158,12 +155,12 @@ module Hobo
     end
 
     def not_found(error)
-      if self.class.superclass.method_defined?(:not_found)
-        self.class.superclass.instance_method(:not_found).bind(self).call(error)
-      elsif render_tag("not-found-page", {}, :status => 404)
+      if self.class.superclass.method_defined?("not_found_response")
+        super
+      elsif render :not_found, :status => 404
         # cool
       else
-        render(:text => ht(:"hobo.messages.not_found", :default=>["The page you requested cannot be found."]) , :status => 404)
+        render(:text => t("hobo.messages.not_found", :default=>["The page you requested cannot be found."]) , :status => 404)
       end
     end
 
@@ -171,10 +168,3 @@ module Hobo
 end
 
 
-class ActionController::Base
-
-  def home_page
-    base_url
-  end
-
-end

data/lib/hobo/controller/authentication_support.rb

@@ -0,0 +1,109 @@
+module Hobo
+  module Controller
+    module AuthenticationSupport
+
+      # Filter method to enforce a login requirement.
+      def logged_in?
+        not current_user.guest?
+      end
+
+
+      # Check if the user is authorized.
+      #
+      # Override this method in your controllers if you want to restrict access
+      # to only a few actions or if you want to check if the user
+      # has the correct rights.
+      #
+      # Example:
+      #
+      #  # only allow nonbobs
+      #  def authorize?
+      #    current_user.login != "bob"
+      #  end
+      def authorized?
+        true
+      end
+
+      #
+      # To require logins for all actions, use this in your controllers:
+      #
+      #   before_filter :login_required
+      #
+      # To require logins for specific actions, use this in your controllers:
+      #
+      #   before_filter :login_required, :only => [ :edit, :update ]
+      #
+      # To skip this in a subclassed controller:
+      #
+      #   skip_before_filter :login_required
+      #
+      def login_required(user_model=nil)
+        auth_model = user_model || Hobo::Model::UserBase.default_user_model
+        if current_user.guest?
+          username, passwd = get_auth_data
+          self.current_user = auth_model.authenticate(username, passwd) || nil if username && passwd && auth_model
+        end
+        if logged_in? && authorized? && (user_model.nil? || current_user.is_a?(user_model))
+          true
+        else
+          access_denied(auth_model)
+        end
+      end
+
+
+      # Store the URI of the current request in the session.
+      #
+      # We can return to this location by calling #redirect_back_or_default.
+      def store_location
+        session[:return_to] = request.fullpath
+      end
+
+      # 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(session[:return_to]) : redirect_to(default)
+        session[:return_to] = nil
+      end
+
+      # 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
+        if (user = authenticated_user_from_cookie)
+          user.remember_me
+          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._?.safe_constantize 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} #{current_user.class.name}",
+                                 :expires => current_user.remember_token_expires_at }
+      end
+
+      private
+      @@http_auth_headers = %w(X-HTTP_AUTHORIZATION HTTP_AUTHORIZATION Authorization)
+      # gets BASIC auth info
+      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?
+        username, pw = if auth_data && auth_data[0] == 'Basic'
+                         Base64.decode64(auth_data[1]).split(':')[0..1]
+                       else
+                         [nil, nil]
+                       end
+      end
+
+    end
+  end
+end