hobo 0.7.2 → 0.7.3

data/hobo_files/plugin/generators/hobo_rapid/templates/themes/clean/public/stylesheets/rapid-ui.css

@@ -17,11 +17,6 @@ table.new-record textarea, table.new-record input {
 	display: inline;	
 }
 
-.edit-page .content-header {overflow: hidden; height: 100%;}
-.edit-page .content-header h1 {float: left;}
-.edit-page .content-header .delete-button {float: right;}
-form .actions {margin: 30px 0;width: 100%; text-align: center;}
-
 /**** Admin ****/
 
 .admin-banner {
@@ -39,25 +34,6 @@ form .actions {margin: 30px 0;width: 100%; text-align: center;}
 	float: right;
 }
 
-/* rails error message */
-.error-messages {
-	font-family: "Lucida Grande", arial, sans-serif;
-	background: #9d0018;
-	border: 1px solid #7a0013;
-	padding: 15px 30px;
-	color: white;
-	margin-bottom: 20px;
-}
-.error-messages h2 {
-	text-transform: none;
-	letter-spacing: normal;
-	color: white;
-	margin-bottom: 10px;
-}
-.error-messages li {
-	margin-left: 20px;
-}
-
 /********* everything below here came from hobo_rapid.css, needs looking at ********/
 
 /**** Default styling for Rapid ***/
@@ -66,30 +42,6 @@ form .actions {margin: 30px 0;width: 100%; text-align: center;}
 	float: right; margin: 20px;
 	position: fixed; display: none; z-index: 10;
 }
-/*
-#ajax-progress {
-    color: grey;
-    float: right;
-    margin: 20px;
-    position: fixed;
-    background: white;
-    font-family: Tahoma "sans serif";
-    display: none;
-	z-index: 10;
-}
-
-#ajax-progress div {
-    border: 1px dashed grey;
-    margin: 10px;
-    padding: 3px;
-    padding-top: -15px;
-}
-
-#ajax-progress img {
-    padding-left: 6px;
-    vertical-align: middle;
-}
-*/
 
 /* Scriptaculous Autocompleter ---*/
 

data/hobo_files/plugin/init.rb

@@ -1,16 +1,21 @@
+# gem dependencies
+require 'hobosupport'
+
+# Force load:
+HoboFields
+
 # Monkey patches, ooh ooh
-require 'extensions'
 require 'rexml'
 require 'active_record/has_many_association'
 require 'active_record/has_many_through_association'
-require 'active_record/table_definition'
+require 'active_record/association_proxy'
+require 'active_record/association_reflection'
 require 'action_view_extensions/base'
 
 require 'hobo'
 require 'hobo/dryml'
 
 require 'hobo/model'
-require 'hobo/field_declaration_dsl'
 
 require 'hobo/dryml/template'
 require 'hobo/dryml/taglib'
@@ -19,16 +24,6 @@ require 'hobo/dryml/template_handler'
 
 require 'extensions/test_case' if RAILS_ENV == "test"
 
-# Rich data types
-require "hobo/html_string"
-require "hobo/markdown_string"
-require "hobo/textile_string"
-require "hobo/password_string"
-require "hobo/text"
-require "hobo/email_address"
-require "hobo/enum_string"
-require "hobo/percentage"
-
 
 ActionView::Base.register_template_handler("dryml", Hobo::Dryml::TemplateHandler)
 
@@ -54,6 +49,7 @@ end
 class ActiveRecord::Base
   def self.hobo_model
     include Hobo::Model
+    fields # force hobofields to load
   end
   def self.hobo_user_model
     include Hobo::Model
@@ -64,3 +60,39 @@ end
 # Default settings
 
 Hobo.developer_features = RAILS_ENV.in?(["development", "test"]) if Hobo.developer_features?.nil?
+
+
+module ::Hobo
+  # Empty class to represent the boolean type.
+  class Boolean; end
+end
+
+
+if defined? HoboFields
+  HoboFields.never_wrap(Hobo::Undefined)
+end
+
+
+# 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_id = origin.try.typed_id
+    "#{origin_id}_#{origin_attribute}" if origin_id
+  end
+  
+end
+
+
+class NilClass
+  def typed_id
+    "nil"
+  end
+end

data/hobo_files/plugin/lib/action_view_extensions/base.rb

@@ -2,12 +2,13 @@ module ActionView
 
   class Base
 
-    alias_method :render_file_without_hobo, :render_file
-    def render_file(template_path, *args)
+    def render_file_with_dryml(template_path, *args)
       @hobo_template_path = template_path
-      render_file_without_hobo(template_path, *args)
+      render_file_without_dryml(template_path, *args)
     end
 
+    alias_method_chain :render_file, :dryml
+
   end
 
 end

data/hobo_files/plugin/lib/active_record/association_proxy.rb

@@ -0,0 +1,18 @@
+module ActiveRecord
+  module Associations
+    class AssociationProxy #:nodoc:
+      
+      private
+      
+      
+      def raise_on_type_mismatch(record)
+        # Don't complain if the interface type of a polymorphic association doesn't exist
+        klass = @reflection.klass rescue nil
+        unless klass.nil? || record.is_a?(klass)
+          raise ActiveRecord::AssociationTypeMismatch, "#{@reflection.klass} expected, got #{record.class}"
+        end
+      end
+        
+    end
+  end
+end

data/hobo_files/plugin/lib/active_record/association_reflection.rb

@@ -0,0 +1,5 @@
+class ActiveRecord::Reflection::AssociationReflection
+  
+  alias_method :association_name, :name
+  
+end

data/hobo_files/plugin/lib/active_record/has_many_association.rb

@@ -18,7 +18,7 @@ module ActiveRecord::Associations
       record = @reflection.klass.new(attributes)
       if hobo_has_many?
         set_belongs_to_association_for(record)
-        set_reverse_association(record)
+        set_reverse_association(record) unless proxy_reflection.options[:as]
       end
       record
     end
@@ -28,17 +28,13 @@ module ActiveRecord::Associations
       proxy_reflection.klass
     end
     
-    
-    def find_with_block(*args, &b)
-      if b
-        options = args.extract_options!
-        args << options.merge(:conditions => member_class.conditions(&b))
-        find_without_block(*args)
-      else
-        find_without_block(*args)
-      end
+    def origin
+      proxy_owner
+    end
+
+    def origin_attribute
+      proxy_reflection.association_name
     end
-    alias_method_chain :find, :block
     
     private
     

data/hobo_files/plugin/lib/active_record/has_many_through_association.rb

@@ -5,6 +5,14 @@ module ActiveRecord::Associations
     def member_class
       proxy_reflection.klass
     end
+    
+    def origin
+      proxy_owner
+    end
+
+    def origin_attribute
+      proxy_reflection.association_name
+    end
 
   end
 

data/hobo_files/plugin/lib/extensions/test_case.rb

@@ -102,7 +102,7 @@ class Test::Unit::TestCase
     def replace_objects_in_params!(hash)
       hash.each do |k,v|
         if v.is_a? ActiveRecord::Base
-          hash[k] = "@" + Hobo.dom_id(v)
+          hash[k] = "@" + v.typed_id
         elsif v.is_a? Hash
           replace_objects_in_params!(v)
         end

data/hobo_files/plugin/lib/hobo.rb

@@ -5,20 +5,12 @@ module Hobo
   class RawJs < String; end
 
   @models = []
-  @field_types = HashWithIndifferentAccess.new
   
   class << self
 
-    attr_accessor :current_theme, :field_types
+    attr_accessor :current_theme
     attr_writer :developer_features
     
-    def symbolic_type_name(type)
-      field_types.index(type)
-    end
-    
-    def type_id(type)
-      symbolic_type_name(type) || type.name.underscore.gsub("/", "__")
-    end
 
     def developer_features?
       @developer_features
@@ -41,7 +33,7 @@ module Hobo
 
     
     def models=(models)
-      @models = models.every(:name)
+      @models = models.*.name
     end
 
     
@@ -52,7 +44,7 @@ module Hobo
         end
         @models_loaded = true
       end
-      @models.every(:constantize)
+      @models.*.constantize
     end
 
     
@@ -87,64 +79,38 @@ module Hobo
     end
 
     def dom_id(obj, attr=nil)
-      if obj.nil?
-        raise ArgumentError, "Tried to get dom id of nil.#{attr}" if attr
-        return 'nil'
-      end
-
-      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)
-        return (if attr
-                  dom_id(get_field(obj, attr))
-                elsif obj.respond_to?(:id)
-                  "#{obj.class.name.underscore}_#{obj.id}"
-                else
-                  raise ArgumentError, "Can't create dom id for #{obj.inspect}"
-                end)
-      end
       attr ? "#{obj.typed_id}_#{attr}" : obj.typed_id
     end
 
-    def find_by_search(query)
-      sql = Hobo.models.map do |model|
-        if model.superclass == ActiveRecord::Base && # filter out STI subclasses
-            ModelRouter.linkable?(nil, model, :show) # filter out non-linkables
-          cols = model.search_columns
-          if cols.blank?
-            nil
-          else
-            where = cols.map {|c| "(#{c} like ?)"}.join(' or ')
-            type = model.column_names.include?("type") ? "type" : "'#{model.name}'"
-            ActiveRecord::Base.send(:sanitize_sql,
-                                    ["select #{type} as type, id " +
-                                     "from #{model.table_name} " +
-                                     "where #{where}"] +
-                                    ["%#{query}%"] * cols.length)
+    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.models.select do |m| 
+          ModelRouter.linkable?(m, :show) && # ...non-linkables
+            m.search_columns.any?             # and models with no search-columns
           end
         end
-      end.compact.join(" union ")
-
-      rows = ActiveRecord::Base.connection.select_all(sql)
-      records = Hash.new {|h,k| h[k] = []}
-      for row in rows
-        records[row['type']] << row['id']
-      end
-      results = []
-      for type, ids in records
-        results.concat(type.constantize.find(:all, :conditions => "id in (#{ids * ','})"))
-      end
       
-      results
+      query_words = ActiveRecord::Base.connection.quote_string(query).split
+                    
+      search_targets.build_hash do |search_target|
+        conditions = query_words.map do |word| 
+          "(" + search_target.search_columns.map { |column| %(#{column} like "%#{word}%") }.join(" or ") + ")"
+        end.join(" and ")
+        
+        results = search_target.find(:all, :conditions => conditions)
+        [search_target.name, results] unless results.empty?
+      end
     end
 
     def add_routes(m)
       Hobo::ModelRouter.add_routes(m)
     end
 
+    
+    # FIXME: This method won't be needed
     def all_models
       Hobo.models.map { |m| m.name.underscore }
     end
@@ -159,6 +125,16 @@ module Hobo
     end
     
     
+    def can_create_in_association?(array_or_reflection)
+      refl = 
+        (array_or_reflection.is_a?(ActiveRecord::Reflection::AssociationReflection) and array_or_reflection) or
+        array_or_reflection.try.proxy_reflection or
+        (origin = array_or_reflection.try.origin and origin.send(array_or_reflection.origin_attribute).try.proxy_reflection)
+
+      refl && refl.macro == :has_many && (!refl.through_reflection) && (!refl.options[:conditions])      
+    end
+    
+    
     def get_field(object, field)
       return nil if object.nil?
       if field.to_s =~ /^\d+$/
@@ -213,10 +189,12 @@ module Hobo
       return false if !can_view?(person, object, field)
       
       if field.nil?
-        if respond_to?(:editable_by?)
+        if object.has_hobo_method?(:editable_by?)
           object.editable_by?(person) 
-        else
+        elsif object.has_hobo_method?(:updatable_by?)
           object.updatable_by?(person, nil)
+        else
+          false
         end
         
       else
@@ -333,7 +311,7 @@ module Hobo
                                 else
                                     File.join(File.dirname(__FILE__), "hobo/static_tags")
                                 end
-                         File.readlines(path).every(:chop)
+                         File.readlines(path).*.chop
                        end
     end
     

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

@@ -38,7 +38,7 @@ module Hobo
     #   skip_before_filter :login_required
     #
     def login_required(user_model=nil)
-      auth_model = user_model || UserController.user_models.first
+      auth_model = user_model || User.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

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

@@ -1,5 +1,3 @@
-require 'extensions'
-
 module ::Hobo
   
   class Bundle
@@ -8,48 +6,93 @@ module ::Hobo
     
     class << self
       
-      attr_accessor :bundles, :plugin
+      # Hobo::Bundle.bundles is a hash of all instantiated bundles by name
+      attr_accessor :bundles
+      
+      # Used by subclasses, e.g MyBundle.plugin is the name of the
+      # plugin the bundle came from
+      attr_reader :plugin
+      
+      attr_reader :model_declarations, :controller_declarations
+      
+      attr_accessor :dirname
       
       def inherited(base)
         filename = caller[0].match(/^(.*):\d+/)[1]
-        dirname = filename.match(%r(^.*/plugins/[^/]+))[0]
-        base.plugin = File.basename(dirname)
+        base.dirname = filename.match(%r(^.*/plugins/[^/]+))[0]
+      end
+
+      
+      def load_models_and_controllers
+        return if models_and_controllers_loaded?
         
-        base.meta_eval do 
-          attr_accessor :models, :controllers
-        end
+        @plugin = File.basename(dirname)
         
-        base.models      = []
-        base.controllers = []
+        @model_declarations      = []
+        @controller_declarations = []
         
-        eval_ruby_files(base, "#{dirname}/models")
-        eval_ruby_files(base, "#{dirname}/controllers") 
+        class_eval do
+          eval_ruby_files("#{dirname}/models", @models)
+          eval_ruby_files("#{dirname}/controllers", @controllers)
+        end
+      end
+      
+      def [](bundle_name)
+        bundles[bundle_name]
       end
       
+
+      private
       
       def bundle_model(name, &block)
-        models << [name, block]
+        @model_declarations << [name, block]
       end
 
       
       def bundle_model_controller(model_name, &block)
-        controllers << [model_name, block]
+        @controller_declarations << [model_name, block]
       end
+
       
+      def models_and_controllers_loaded?
+        @model_declarations
+      end
       
-      private
       
-      def eval_ruby_files(base, dir)
-        Dir["#{dir}/*.rb"].each do |f|
-          base.instance_eval(File.read(f), f, 1)
-        end
+      
+      def eval_ruby_files(dir, filenames)
+        files = if filenames == [:none]
+                  []
+                elsif filenames.blank? || filenames == [:all]
+                  Dir["#{dir}/*.rb"]
+                else
+                  filenames.map { |f| "#{dir}/#{f}.rb" }
+                end
+        
+        files.each { |f| instance_eval(File.read(f), f, 1) }
+      end
+      
+      
+      # Declatations
+      
+      def models(*models)
+        @models = models
+      end
+      
+      def controllers(*controllers)
+        @controllers = controllers.map {|c| case c.to_s
+                                              when /controller$/, "all", "none" then c
+                                              else "#{c.to_s.pluralize}_controller" 
+                                            end }
       end
       
     end
     
     def initialize(*args)
+      self.class.load_models_and_controllers
+      
       options = defaults.with_indifferent_access
-      options.update(args.extract_options!)
+      options.recursive_update(args.extract_options!)
       
       self.name = args.first || self.class.name.match(/[^:]+$/)[0].underscore
       Bundle.bundles[name] = self
@@ -78,18 +121,52 @@ module ::Hobo
     
     
     def create_models
-      self.class.models.each do |name, block|
-        klass = make_class(new_name_for(name), ActiveRecord::Base) do
-          hobo_model
+      self.class.model_declarations.each do |name, block|
+        klass = make_class(new_name_for(name), ActiveRecord::Base)
+        
+        klass.meta_def :belongs_to_with_optional_polymorphism do |*args|
+          opts = args.extract_options!
+          
+          if opts[:polymorphic] == :optional
+            if bundle.options["polymorphic_#{name}"]
+              opts[:polymorphic] = true
+              opts.delete(:class_name)
+            else
+              opts.delete(:polymorphic)
+            end
+          end
+          belongs_to_without_optional_polymorphism(name, opts)
         end
-        klass.class_eval(&block)
+        klass.meta_eval { alias_method_chain :belongs_to, :optional_polymorphism }
+        
+        klass.class_eval { hobo_model }
+        
+        # FIXME this extension breaks passing a block to belongs_to
+        klass.meta_def :belongs_to_with_alias do |*args|
+          opts = args.extract_options!
+          name = args.first.to_sym
+          
+          alias_name = opts.delete(:alias)
+          
+          belongs_to_without_alias(name, opts)
+
+          if alias_name && name != alias_name
+            klass.send(:alias_method, alias_name, name)
+            # make the aliased name available in the classes metadata
+            klass.reflections[alias_name] = klass.reflections[name]
+          end
+          
+        end
+        klass.meta_eval { alias_method_chain :belongs_to, :alias }
+
+        klass.class_eval(&block)        
       end
     end
     
     
     def create_controllers
       bundle = self
-      self.class.controllers.each do |model_name, block|
+      self.class.controller_declarations.each do |model_name, block|
         klass = make_class("#{new_name_for(model_name).to_s.pluralize}Controller", ApplicationController) do 
           hobo_model_controller
         end
@@ -106,6 +183,14 @@ module ::Hobo
         def self.feature(name, &block)
           _feature(name, block)
         end
+        
+        def method_missing(name, *args)
+          if name.to_s =~ /^_.*_$/
+            self.class.bundle.magic_option(name)
+          else
+            super
+          end
+        end
       end
       
       klass.meta_def(:bundle) do 
@@ -134,19 +219,23 @@ module ::Hobo
       end
       
       klass.class_eval(&b) if b
+      
       klass
     end
     
     
     def new_name_for(name)
-      while renames.has_key?(name)
-        name = renames[name] 
-        name2 = name.to_s.gsub(/_.*?_/) { |s| new_name_for(s[1..-2]) }
-        
-        # Make sure symbols stay symbols
-        name = name.is_a?(Symbol) ? name2.to_sym : name2
+      while true
+        if renames.has_key?(name)
+          name = renames[name]
+        elsif name.to_s =~ /_.*?_/
+          name2 = name.to_s.gsub(/_.*?_/) { |s| new_name_for(s[1..-2]) }
+          # Make sure symbols stay symbols
+          name = name.is_a?(Symbol) ? name2.to_sym : name2
+        else
+          return name
+        end
       end
-      name
     end
     
     
@@ -169,7 +258,7 @@ module ::Hobo
       new_name_for(name).to_s.constantize.class_eval(&block)
     end
     
-    
+
     def method_missing(name, *args)
       if name.to_s =~ /^_.*_$/
         magic_option(name)
@@ -213,7 +302,15 @@ module ::Hobo
       external_options = self.options[option_name]
       external_options = {} if external_options.nil? || external_options == true
       name = "#{self.name}_#{option_name}"
-      class_name.to_s.constantize.new(name, external_options.merge(local_options).merge(renames))
+
+      sub_bundle_options = external_options.merge(local_options).merge(renames)
+      sub_bundle = class_name.to_s.constantize.new(name, sub_bundle_options)
+      
+      conflicting_renames = (renames.keys & sub_bundle.renames.keys).select { |k| renames[k] != sub_bundle.renames[k] }
+      unless conflicting_renames.empty?
+        raise ArgumentError, "Conflicting renames in included bundle '#{name}' of '#{self.name}': #{conflicting_renames * ', '}"
+      end
+      renames.update(sub_bundle.renames)
       self.options["#{option_name}_bundle"] = name
     end