hobo 0.9.0 → 0.9.100

data/lib/hobo/model.rb

@@ -24,6 +24,7 @@ module Hobo
         include Hobo::Lifecycles::ModelExtensions
         include Hobo::FindFor
         include Hobo::AccessibleAssociations
+        include Hobo::Translations
       end
 
       class << base
@@ -35,14 +36,14 @@ module Hobo
 
         def inherited(klass)
           super
-          fields do
+          fields(false) do
             Hobo.register_model(klass)
             field(klass.inheritance_column, :string)
           end
         end
       end
       
-      base.fields # force hobofields to load
+      base.fields(false) # force hobofields to load
 
       included_in_class_callbacks(base)
     end
@@ -121,7 +122,7 @@ module Hobo
       ActiveRecord::Base.class_eval do
         def self.hobo_model
           include Hobo::Model
-          fields # force hobofields to load
+          fields(false) # force hobofields to load
         end
         def self.hobo_user_model
           include Hobo::Model
@@ -141,12 +142,12 @@ module Hobo
       # TODO: should this be an inheriting_cattr_accessor as well? Probably.
       attr_accessor :creator_attribute
       inheriting_cattr_accessor :name_attribute => Proc.new { |c|
-        names = c.columns.*.name + c.public_instance_methods
+        names = c.columns.*.name + c.public_instance_methods.*.to_s
         NAME_FIELD_GUESS.detect {|f| f.in? names }
       }
 
       inheriting_cattr_accessor :primary_content_attribute => Proc.new { |c|
-        names = c.columns.*.name + c.public_instance_methods
+        names = c.columns.*.name + c.public_instance_methods.*.to_s
         PRIMARY_CONTENT_GUESS.detect {|f| f.in? names }
       }
 
@@ -168,25 +169,6 @@ module Hobo
       end
 
 
-      def dependent_collections
-        reflections.values.select do |refl|
-          refl.macro == :has_many && refl.options[:dependent]
-        end.*.name
-      end
-
-
-      def dependent_on
-        reflections.values.select do |refl|
-          refl.macro == :belongs_to && (rev = reverse_reflection(refl.name) and rev.options[:dependent])
-        end.*.name
-      end
-
-
-      def default_dependent_on
-        dependent_on.first
-      end
-
-
       private
 
 
@@ -273,14 +255,18 @@ module Hobo
 
       def find(*args, &b)
         options = args.extract_options!
-        if options[:order] == :default
+        if options[:order] == :default || (options[:order].blank? && !scoped?(:find, :order))
+          # TODO: decide if this is correct. AR is no help, as passing :order to a scoped proxy
+          #       MERGES the order, but nesting two scopes with :order completely ignores the 
+          #       first scope's order.
+          #       Are we more like default_scope, or more like passing :order => model.default_order?
           options = if default_order.blank?
                       options.except :order
                     else
                       options.merge(:order => if default_order[/(\.|\(|,| )/]
                                                 default_order
                                               else
-                                                "#{table_name}.#{default_order}"
+                                                "#{quoted_table_name}.#{default_order}"
                                               end)
                     end
         end
@@ -297,11 +283,6 @@ module Hobo
       end
 
 
-      def all(options={})
-        find(:all, options.reverse_merge(:order => :default))
-      end
-
-
       def creator_type
         attr_type(creator_attribute)
       end
@@ -329,6 +310,7 @@ module Hobo
           refl.klass.reflections.values.find do |r|
             r.macro == :has_many &&
               !r.options[:conditions] &&
+              !r.options[:scope] &&
               r.through_reflection == other_to_join && 
               r.source_reflection  == join_to_self
           end
@@ -346,6 +328,7 @@ module Hobo
             r.macro.in?(reverse_macros) &&
               r.klass >= self &&
               !r.options[:conditions] &&
+              !r.options[:scope] &&
               r.primary_key_name == refl.primary_key_name
           end
         end
@@ -410,11 +393,6 @@ module Hobo
     end
 
 
-    def dependent_on
-      self.class.dependent_on.map { |assoc| send(assoc) }
-    end
-
-
     def attributes_with_hobo_type_conversion=(attributes, guard_protected_attributes=true)
       converted = attributes.map_hash { |k, v| convert_type_for_mass_assignment(self.class.attr_type(k), v) }
       send(:attributes_without_hobo_type_conversion=, converted, guard_protected_attributes)

data/lib/hobo/model_controller.rb

@@ -166,7 +166,7 @@ module Hobo
 
 
       def def_auto_action(name, &block)
-        define_method name, &block if name.not_in?(instance_methods) && include_action?(name)
+        define_method name, &block if !method_defined?(name) && include_action?(name)
       end
 
 
@@ -259,7 +259,7 @@ module Hobo
       
       def auto_actions_for(owner, actions)
         name = model.reflections[owner].macro == :has_many ? owner.to_s.singularize : owner
-        
+
         owner_actions[owner] ||= []
         Array(actions).each do |action|
           case action
@@ -296,7 +296,7 @@ module Hobo
 
 
       def available_auto_write_actions
-        if "position_column".in?(model.instance_methods)
+        if model.method_defined?("position_column")
           WRITE_ONLY_ACTIONS + [:reorder]
         else
           WRITE_ONLY_ACTIONS
@@ -393,7 +393,7 @@ module Hobo
     end
 
     def owning_object
-      method = @this.class.dependent_on.detect {|m| !@this.send(m).nil?}
+      method = @this.class.view_hints.parent
       method ? @this.send(method) : nil
     end
     
@@ -461,14 +461,17 @@ module Hobo
     
     
     def find_owner_and_association(owner_association)
+      owner_name = name_of_auto_action_for(owner_association)
       refl = model.reflections[owner_association]
-      owner_name = refl.macro == :has_many ? owner_association.to_s.singularize : owner_association
       id = params["#{owner_name}_id"]
       owner = refl.klass.find(id)
       instance_variable_set("@#{owner_association}", owner)
       [owner, owner.send(model.reverse_reflection(owner_association).name)]
     end
 
+    def name_of_auto_action_for(owner_association)
+      model.reflections[owner_association].macro == :has_many ? owner_association.to_s.singularize : owner_association
+    end
 
     # --- Action implementations --- #
 
@@ -511,18 +514,28 @@ module Hobo
 
     def hobo_create(*args, &b)
       options = args.extract_options!
-      self.this ||= args.first || new_for_create
-      this.user_update_attributes(current_user, options[:attributes] || attribute_parameters || {})
+      attributes = options[:attributes] || attribute_parameters || {}      
+      if self.this ||= args.first
+        this.user_update_attributes(current_user, attributes)
+      else
+        self.this = new_for_create(attributes)
+        this.save
+      end
       create_response(:new, options, &b)
     end
     
     
-    def hobo_create_for(owner, *args, &b)
+    def hobo_create_for(owner_association, *args, &b)
       options = args.extract_options!
-      owner, association = find_owner_and_association(owner)
-      self.this ||= args.first || association.new
-      this.user_update_attributes(current_user, options[:attributes] || attribute_parameters || {})
-      create_response(:"new_for_#{owner}", options, &b)    
+      owner, association = find_owner_and_association(owner_association)
+      attributes = options[:attributes] || attribute_parameters || {}
+      if self.this ||= args.first
+        this.user_update_attributes(current_user, attributes)
+      else
+        self.this = association.new(attributes)
+        this.save
+      end
+      create_response(:"new_for_#{name_of_auto_action_for(owner_association)}", options, &b)    
     end
 
 
@@ -531,10 +544,10 @@ module Hobo
     end
 
 
-    def new_for_create
+    def new_for_create(attributes = {})
       type_param = subtype_for_create
       create_model = type_param ? type_param.constantize : model
-      create_model.user_new(current_user)
+      create_model.user_new(current_user, attributes)
     end
     
     
@@ -755,7 +768,7 @@ module Hobo
       self.this = true # Otherwise this gets sent user_view
       logger.info "Hobo: Permission Denied!"
       @permission_error = error
-      if "permission_denied".in?(self.class.superclass.instance_methods)
+      if self.class.superclass.method_defined?("permission_denied")
         super
       else
         respond_to do |wants|

data/lib/hobo/model_router.rb

@@ -248,7 +248,7 @@ module Hobo
 
 
     def named_route(name, route, options={})
-      if controller.public_instance_methods.include?(options[:action].to_s)
+      if controller.public_method_defined?(options[:action])
         options.reverse_merge!(:controller => route_with_subsite(plural))
         name = name_with_subsite(name)
         route = route_with_subsite(route)

data/lib/hobo/permissions.rb

@@ -13,7 +13,12 @@ module Hobo
         alias_method_chain :create, :hobo_permission_check
         alias_method_chain :update, :hobo_permission_check
         alias_method_chain :destroy, :hobo_permission_check
-
+        class << self
+          alias_method_chain :has_many, :hobo_permission_check
+          alias_method_chain :has_one, :hobo_permission_check
+          alias_method_chain :belongs_to, :hobo_permission_check
+        end                  
+        
         attr_accessor :acting_user, :origin, :origin_attribute
 
         bool_attr_accessor :exempt_from_edit_checks
@@ -25,9 +30,9 @@ module Hobo
     def self.find_aliased_name(klass, method_name)
       # The method +method_name+ will have been aliased. We jump through some hoops to figure out
       # what it's new name is
-      method_name = method_name.to_s
+      method_name = method_name.to_sym
       method = klass.instance_method method_name
-      methods = klass.private_instance_methods + klass.instance_methods
+      methods = (klass.private_instance_methods + klass.instance_methods).*.to_sym
       new_name = methods.select {|m| klass.instance_method(m) == method }.find { |m| m != method_name }
     end
     
@@ -75,7 +80,52 @@ module Hobo
       def viewable_by?(user, attribute=nil)
         new.viewable_by?(user, attribute)
       end
+      
+      #  ensure active_user gets passed down to :dependent => destroy
+      #  associations  (Ticket #528)
 
+      def has_many_with_hobo_permission_check(association_id, options = {}, &extension)
+        has_many_without_hobo_permission_check(association_id, options, &extension)
+        reflection = reflections[association_id]
+        if reflection.options[:dependent]==:destroy
+          #overriding dynamic method created in ActiveRecord::Associations#configure_dependency_for_has_many
+          method_name =  "has_many_dependent_destroy_for_#{reflection.name}".to_sym
+          define_method(method_name) do
+            send(reflection.name).each { |r| r.is_a?(Hobo::Model) ? r.user_destroy(acting_user) : r.destroy }
+          end
+        end        
+      end       
+      
+      def has_one_with_hobo_permission_check(association_id, options = {}, &extension)
+        has_one_without_hobo_permission_check(association_id, options, &extension)
+        reflection = reflections[association_id]
+        if reflection.options[:dependent]==:destroy
+          #overriding dynamic method created in ActiveRecord::Associations#configure_dependency_for_has_many
+          method_name =  "has_one_dependent_destroy_for_#{reflection.name}".to_sym
+          define_method(method_name) do            
+            association = send(reflection.name)
+            unless association.nil?
+              association.is_a?(Hobo::Model) ? association.user_destroy(active_user) : association.destroy
+            end
+          end
+        end        
+      end       
+     
+      def belongs_to_with_hobo_permission_check(association_id, options = {}, &extension)
+        belongs_to_without_hobo_permission_check(association_id, options, &extension)
+        reflection = reflections[association_id]
+        if reflection.options[:dependent]==:destroy
+          #overriding dynamic method created in ActiveRecord::Associations#configure_dependency_for_has_many
+          method_name =  "belongs_to_dependent_destroy_for_#{reflection.name}".to_sym
+          define_method(method_name) do            
+            association = send(reflection.name)
+            unless association.nil?
+              association.is_a?(Hobo::Model) ? association.user_destroy(active_user) : association.destroy
+            end
+          end
+        end        
+      end       
+       
     end
     
     
@@ -123,8 +173,8 @@ module Hobo
       result
     end
     
-    def user_save(user)
-      with_acting_user(user) { save }
+    def user_save(user, validate = true)
+      with_acting_user(user) { save(validate) }
     end
         
     def user_save!(user)

data/lib/hobo/permissions/associations.rb

@@ -45,12 +45,20 @@ module Hobo
           end
 
 
-          def insert_record(record)
+          def insert_record(record, force = false, validate = true)
             set_belongs_to_association_for(record)
             if (user = acting_user) && record.is_a?(Hobo::Model)
-              record.user_save(user)
+              if force
+                record.user_save!(user)
+              else
+                record.user_save(user, validate)
+              end
             else
-              record.save
+               if force 
+                 record.save!
+               else
+                 record.save(validate)
+               end
             end
           end
           
@@ -99,13 +107,13 @@ module Hobo
           end
         
         
-          def insert_record(record, force=true)
+          def insert_record(record, force=true, validate=true)
             user = acting_user if record.is_a?(Hobo::Model)
             if record.new_record?
               if force
                 user ? record.user_save!(user) : record.save!
               else
-                return false unless (user ? record.user_save(user) : record.save)
+                return false unless (user ? record.user_save(user, validate) : record.save(validate))
               end
             end
             klass = @reflection.through_reflection.klass

data/lib/hobo/rapid_helper.rb

@@ -92,13 +92,16 @@ module Hobo::RapidHelper
 
 
 
-  def in_place_editor(attributes)
+  def in_place_editor(attributes, this=nil)
     blank_message = attributes.delete(:blank_message) || "(click to edit)"
 
     attributes = add_classes(attributes, "in-place-edit", model_id_class(this_parent, this_field))
     attributes.update(:hobo_blank_message => blank_message,
                       :if_blank => blank_message,
                       :no_wrapper => false)
+    
+    edit_text = this._?.to_s
+    attributes.update(:hobo_edit_text => edit_text) unless edit_text.nil?
 
     update = attributes.delete(:update)
     attributes[:hobo_update] = update if update
@@ -122,15 +125,6 @@ module Hobo::RapidHelper
   end
 
 
-  def primary_collection_name(object=this)
-    dependent_collection_names = object.class.reflections.values.select do |refl|
-      refl.macro == :has_many && refl.options[:dependent]
-    end.*.name
-
-    (dependent_collection_names - through_collection_names(object)).first
-  end
-
-
   def non_through_collections(object=this)
     names = object.class.reflections.values.select do |refl|
       refl.macro == :has_many

data/lib/hobo/scopes/automatic_scopes.rb

@@ -347,7 +347,15 @@ module Hobo
 
 
       def def_scope(options={}, &block)
-        @klass.named_scope(name.to_sym, block || options)
+        _name = name.to_sym
+        @klass.named_scope(_name, block || options)
+        # this is tricky; ordinarily, we'd worry about subclasses that haven't yet been loaded.
+        # HOWEVER, they will pick up the scope setting via read_inheritable_attribute when they do
+        # load, so only the currently existing subclasses need to be fixed up.
+        _scope = @klass.scopes[_name]
+        @klass.send(:subclasses).each do |k|
+          k.scopes[_name] = _scope
+        end
       end
 
 

data/lib/hobo/translations.rb

@@ -0,0 +1,88 @@
+module Hobo
+
+  module Translations
+
+    # --- Translation Helper --- #
+    #
+    # Uses RoR native I18n.translate.
+    #
+    # Adds some conventions for easier hobo translation. 
+    # 1. Assumes the first part of the key to be a model name (e.g.: users.index.title -> user)
+    # 2. Tries to translate the model by lookup for: (e.g.: user-> activerecord.models.user)
+    # 3. Adds a default fallback to the beginning of the fallback chain 
+    #    by replacing the first part of the key with "hobo" and using the translated model name 
+    #    as additional attribute. This allows us to have default translations 
+    #    (e.g.: hobo.index.title: "{{model}} Index")
+    # 
+    # Is also used as a tag in the dryml-view files. The syntax is:
+    # <ht key="my.app">My Application</ht>
+    #   --> Will lookup the "my.app"-key for your locale and replaces the "My Application" content 
+    #       if found.
+    #
+    # <ht key="my" app="Program">My Application</ht>
+    #   --> Will look up both the "my"- and "app"-key for your locale, and replaces the 
+    #       "My Application" with the "my"-key contents (interpolated using the "app"-key.
+    #       sample.en.yml-file:
+    #       "no":
+    #         my: "Mitt {{app}}"
+    #       The output should be: Mitt Program
+    # 
+    # Otherwise with features as the ht method, step 1, 2 and 3 above. 
+    def self.ht(key, options={})
+      
+      # Check if called as a tag, i.e. like this <ht></ht>
+      if (key.class == Hash)
+        if key.has_key?(:default) && !key[:default].blank?
+          Rails.logger.warn "hobo-i18n: 'default' should not be used as an attribute on the ht-tag. If used, then you need to make sure that the tags inner-contents are not used. These are normally treated as defaults automatically, but if there is a default attribute then that inner-content will be hidden from this method - and will not be replaced with the translation found."
+        end
+        defaults = options[:default];
+        # Swap key and options, remove options[:key] 
+        options = key 
+        key = options.delete(:key) # returns value for options[:key] as well as deleting it
+        # Set options[:default] to complete the tag-argument-conversion process.
+        options[:default] = (defaults.class == Proc) ? [defaults.call(options)] : (options[:default].blank? ? [] : [options[:default]])
+      else
+        # Not called as a tag. Prepare options[:default].
+        if options[:default].nil?
+          options[:default]=[]
+        elsif options[:default].class != Array
+          options[:default] = [options[:default]]
+        end
+      end
+      
+      # assume the first part of the key to be the model
+      keys = key.to_s.split(".")
+      if keys.length > 1
+        model = keys.shift()
+        subkey = keys.join(".")
+      else
+        subkey = key
+      end
+    
+      # add :"hobo.#{key}" as the first fallback
+      options[:default].unshift("hobo.#{subkey}".to_sym)
+    
+      # translate the model
+      unless model.blank?
+        translated_model = I18n.translate( "activerecord.models.#{model.singularize.underscore}", :default=>model).titleize
+        options[:model] = translated_model
+      end
+    
+      key_prefix = "<span class='translation-key'>#{key}</span>" if defined?(HOBO_SHOW_LOCALE_KEYS) && HOBO_SHOW_LOCALE_KEYS
+    
+      Rails.logger.info "..translate(#{key}, #{options.inspect}) to #{I18n.locale}" if defined?(HOBO_VERBOSE_TRANSLATIONS)
+      
+      I18n.translate(key.to_sym, options)+(key_prefix ? key_prefix:"")
+    end
+
+    # if somebody includes us, give them ht as an instance method
+    def self.included(base)
+      translation_class = self
+      base.class_eval do
+        define_method :ht do |*args|
+          translation_class.ht(*args)
+        end
+      end
+    end
+  end
+end