hobo 1.0.3 → 1.1.0.pre0

data/lib/hobo/hobo_helper.rb

@@ -157,70 +157,6 @@ module Hobo
       object.respond_to?(:typed_id) ? "model::#{typed_id(object, attribute).to_s.dasherize}" : ""
     end
 
-
-    def context_map(enum = this)
-      # TODO: Calls to respond_to? in here can cause the full collection hiding behind a scoped collection to get loaded
-      res = []
-      empty = true
-      scope.new_scope(:repeat_collection => enum, :even_odd => 'odd', :repeat_item => nil) do
-        if enum.respond_to?(:each_pair)
-          enum.each_pair do |key, value|
-            scope.repeat_item = value
-            empty = false;
-            self.this_key = key;
-            new_object_context(value) { res << yield }
-            scope.even_odd = scope.even_odd == "even" ? "odd" : "even"
-          end
-        else
-          index = 0
-          enum.each do |e|
-            scope.repeat_item = e
-            empty = false;
-            if enum == this
-              new_field_context(index, e) { res << yield }
-            else
-              new_object_context(e) { res << yield }
-            end
-            scope.even_odd = scope.even_odd == "even" ? "odd" : "even"
-            index += 1
-          end
-        end
-        Dryml.last_if = !empty
-      end
-      res
-    end
-    
-    
-    def first_item?
-      if scope.repeat_collection.respond_to? :each_pair
-        this == scope.repeat_collection.first.try.last
-      else
-        this == scope.repeat_collection.first
-      end
-    end
-    
-    
-    def last_item?
-      if scope.repeat_collection.respond_to? :each_pair
-        this == scope.repeat_collection.last.try.last
-      else
-        this == scope.repeat_collection.last
-      end
-    end
-
-
-    def comma_split(x)
-      case x
-      when nil
-        []
-      when String
-        x.strip.split(/\s*,\s*/)
-      else
-        x.compact.map{|e| comma_split(e)}.flatten
-      end
-    end
-
-
     def can_create?(object=this)
       if object.is_a?(Class) and object < ActiveRecord::Base
         object = object.new
@@ -358,26 +294,6 @@ module Hobo
       s.to_s.gsub("\n", "<br/>") if s
     end
 
-
-    def param_name_for(path)
-      field_path = field_path.to_s.split(".") if field_path.is_one_of?(String, Symbol)
-      attrs = path.rest.map{|part| "[#{part.to_s.sub /\?$/, ''}]"}.join
-      "#{path.first}#{attrs}"
-    end
-
-
-    def param_name_for_this(foreign_key=false)
-      return "" unless form_this
-      name = if foreign_key && (refl = this_field_reflection) && refl.macro == :belongs_to
-               param_name_for(path_for_form_field[0..-2] + [refl.primary_key_name])
-             else
-               param_name_for(path_for_form_field)
-             end
-      register_form_field(name)
-      name
-    end
-
-
     def transpose_with_field(field, collection=nil)
       collection ||= this
       matrix = collection.map {|obj| obj.send(field) }

data/lib/hobo/lifecycles/lifecycle.rb

@@ -24,36 +24,45 @@ module Hobo
 
       def self.def_state(name, on_enter)
         name = name.to_sym
-        class_eval "def #{name}_state?; state_name == :#{name} end"
-        states[name] = Lifecycles::State.new(name, on_enter)
+        returning(Lifecycles::State.new(name, on_enter)) do |s|
+          states[name] = s
+          class_eval "def #{name}_state?; state_name == :#{name} end"
+        end
       end
 
 
       def self.def_creator(name, on_create, options)
-        class_eval %{
-                     def self.#{name}(user, attributes=nil)
-                       create(:#{name}, user, attributes)
-                     end
-                     def self.can_#{name}?(user, attributes=nil)
-                       can_create?(:#{name}, user)
-                     end
-                    }
-        Creator.new(self, name.to_s, on_create, options)
+        name = name.to_sym
+        returning(Creator.new(self, name, on_create, options)) do |creator|
+
+          class_eval %{
+                       def self.#{name}(user, attributes=nil)
+                         create(:#{name}, user, attributes)
+                       end
+                       def self.can_#{name}?(user, attributes=nil)
+                         can_create?(:#{name}, user)
+                       end
+                      }
+
+       end
       end
 
       def self.def_transition(name, start_state, end_states, on_transition, options)
-        class_eval %{
-                     def #{name}!(user, attributes=nil)
-                       transition(:#{name}, user, attributes)
-                     end
-                     def can_#{name}?(user, attributes=nil)
-                       can_transition?(:#{name}, user)
-                     end
-                     def valid_for_#{name}?
-                       valid_for_transition?(:#{name})
-                     end
-                    }
-        Transition.new(self, name.to_s, start_state, end_states, on_transition, options)
+        returning(Transition.new(self, name.to_s, start_state, end_states, on_transition, options)) do |t|
+
+          class_eval %{
+                       def #{name}!(user, attributes=nil)
+                         transition(:#{name}, user, attributes)
+                       end
+                       def can_#{name}?(user, attributes=nil)
+                         can_transition?(:#{name}, user)
+                       end
+                       def valid_for_#{name}?
+                         valid_for_transition?(:#{name})
+                       end
+                      }
+
+        end
       end
 
       def self.state_names
@@ -84,7 +93,7 @@ module Hobo
 
 
       def self.create(name, user, attributes=nil)
-        creator = creators[name.to_sym]
+        creator = creators[name.to_sym] or raise LifecycleError, "No creator #{name} available"
         creator.run!(user, attributes)
       end
 
@@ -116,8 +125,8 @@ module Hobo
 
 
       def transition(name, user, attributes)
-        transition = find_transition(name, user)
-        transition.run!(record, user, attributes) unless transition.nil?
+        transition = find_transition(name, user) or raise LifecycleError, "No transition #{name} available"
+        transition.run!(record, user, attributes)
       end
 
 
@@ -168,6 +177,7 @@ module Hobo
       def become(state_name, validate=true)
         state_name = state_name.to_sym
         record.write_attribute self.class.state_field, state_name.to_s
+
         if state_name == :destroy
           record.destroy
           true
@@ -209,7 +219,7 @@ module Hobo
         timestamp = record.read_attribute(key_timestamp_field)
         if timestamp
           timestamp = timestamp.getutc
-          Digest::SHA1.hexdigest("#{record.id}-#{state_name}-#{timestamp}-#{ActionController::Base.session_options[:secret]}")
+          Digest::SHA1.hexdigest("#{record.id}-#{state_name}-#{timestamp}")
         end
       end
 
@@ -222,10 +232,6 @@ module Hobo
         provided_key && provided_key == key && !key_expired?
       end
 
-      def clear_key
-        record.write_attribute key_timestamp_field, nil
-      end
-
       def invariants_satisfied?
         self.class.invariants.all? { |i| record.instance_eval(&i) }
       end

data/lib/hobo/lifecycles/transition.rb

@@ -34,8 +34,7 @@ module Hobo
 
 
       def change_state(record)
-        record.lifecycle.clear_key unless options[:new_key] || options[:keep_key]
-        return record.lifecycle.become(get_state(record, end_state))
+        record.lifecycle.become(get_state(record, end_state))
       end
 
 

data/lib/hobo/model.rb

@@ -34,17 +34,13 @@ module Hobo
 
         alias_method_chain :has_one, :new_method
 
-        # eval avoids the ruby 1.9.2 "super from singleton method ..." error
-        # see LH#840
-        eval %(
-          def inherited(klass)
-            super
-            fields(false) do
-              Hobo.register_model(klass)
-              field(klass.inheritance_column, :string)
-            end
+        def inherited(klass)
+          super
+          fields(false) do
+            Hobo.register_model(klass)
+            field(klass.inheritance_column, :string)
           end
-        )
+        end
       end
       
       base.fields(false) # force hobofields to load
@@ -61,11 +57,11 @@ module Hobo
 
         WillPaginate::Finder::ClassMethods.class_eval do
           def paginate_with_hobo_metadata(*args, &block)
-            collection = paginate_without_hobo_metadata(*args, &block)
-            collection.member_class     = self
-            collection.origin           = try.proxy_owner
-            collection.origin_attribute = try.proxy_reflection._?.name
-            collection
+            returning paginate_without_hobo_metadata(*args, &block) do |collection|
+              collection.member_class     = self
+              collection.origin           = try.proxy_owner
+              collection.origin_attribute = try.proxy_reflection._?.name
+            end
           end
           alias_method_chain :paginate, :hobo_metadata
 
@@ -125,12 +121,8 @@ module Hobo
 
       ActiveRecord::Base.class_eval do
         def self.hobo_model
-          if self.ancestors.include?(Hobo::Model)
-            Rails.logger.error "#{self}: Do not call hobo_model in derived classes."
-          else
-            include Hobo::Model
-            fields(false) # force hobofields to load
-          end
+          include Hobo::Model
+          fields(false) # force hobofields to load
         end
         def self.hobo_user_model
           include Hobo::Model

data/lib/hobo/model_controller.rb

@@ -521,7 +521,7 @@ module Hobo
         this.user_update_attributes(current_user, attributes)
       else
         self.this = new_for_create(attributes)
-        this.user_save(current_user)
+        this.save
       end
       create_response(:new, options, &b)
     end
@@ -590,11 +590,10 @@ module Hobo
 
       self.this ||= args.first || find_instance
       changes = options[:attributes] || attribute_parameters or raise RuntimeError, ht(:"hobo.messages.update.no_attribute_error", :default=>["No update specified in params"])
-      
-      if this.user_update_attributes(current_user, changes)        
-        # Ensure current_user isn't out of date
-        @current_user = @this if @this == current_user
-      end
+      this.user_update_attributes(current_user, changes)
+
+      # Ensure current_user isn't out of date
+      @current_user = @this if @this == current_user
 
       in_place_edit_field = changes.keys.first if changes.size == 1 && params[:render]
       update_response(in_place_edit_field, options, &b)
@@ -755,7 +754,8 @@ module Hobo
       ordering = params["#{model.name.underscore}_ordering"]
       if ordering
         ordering.each_with_index do |id, position|
-          model.find(id).user_update_attributes(current_user, :position => position+1)
+          object = model.find(id)
+          object.user_update_attributes!(current_user, object.position_column => position+1)
         end
         hobo_ajax_response || render(:nothing => true)
       else
@@ -772,7 +772,7 @@ module Hobo
       logger.info "Hobo: Permission Denied!"
       @permission_error = error
       if self.class.superclass.method_defined?("permission_denied")
-        super
+        self.class.superclass.instance_method(:permission_denied).bind(self).call(error)
       else
         respond_to do |wants|
           wants.html do

data/lib/hobo/rapid_helper.rb

@@ -1,5 +1,16 @@
 module Hobo::RapidHelper
 
+  def comma_split(x)
+    case x
+    when nil
+      []
+    when String
+      x.strip.split(/\s*,\s*/)
+    else
+      x.compact.map{|e| comma_split(e)}.flatten
+    end
+  end
+
   def rapid_build_callbacks(options)
     callbacks = {}
     options.each do |callback, code|
@@ -113,7 +124,7 @@ module Hobo::RapidHelper
 
   AJAX_CALLBACKS = [ :before, :success, :failure, :complete ]
 
-  AJAX_ATTRS = AJAX_CALLBACKS + [ :type, :method,
+  AJAX_ATTRS = AJAX_CALLBACKS + [ :update, :type, :method,
                                   :script, :form, :params, :confirm, :message,
                                   :reset_form, :refocus_form, :result_update, :spinner_next_to ]
 

data/lib/hobo/scopes/automatic_scopes.rb

@@ -56,6 +56,19 @@ module Hobo
             { :conditions => [exists_sql, record] }
           end
 
+        # any_of_players(player1, player2)
+        elsif name =~ /^any_of_(.*)/ && (refl = reflection($1))
+
+          def_scope do |*records|
+            if records.empty?
+              { :conditions => exists_sql_condition(refl, true) }
+            else
+              records = records.flatten.compact.map {|r| find_if_named(refl, r) }
+              exists_sql = ([exists_sql_condition(refl)] * records.length).join(" OR ")
+              { :conditions => [exists_sql] + records }
+            end
+          end
+
         # without_players(player1, player2)
         elsif name =~ /^without_(.*)/ && (refl = reflection($1))
 
@@ -255,7 +268,7 @@ module Hobo
               type = klass.attr_type(field)
               if type.nil? #a virtual attribute from an SQL alias, e.g., 'total' from 'COUNT(*) AS total'
                 colspec = "#{field}" # don't prepend the table name 
-              elsif type.respond_to?(:name_attribute) && (name = type.name_attribute)
+              elsif type.respond_to?(:table_name) && (name = type.name_attribute)
                 include = field
                 colspec = "#{type.table_name}.#{name}"
               else
@@ -270,17 +283,14 @@ module Hobo
               { :include => inclusions }
             end
 
-          when "includes"
-            def_scope do |inclusions|
-              { :include => inclusions }
-            end
-
           when "search"
             def_scope do |query, *fields|
+              match_keyword = ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL" ? "ILIKE" : "LIKE"
+
               words = query.split
               args = []
               word_queries = words.map do |word|
-                field_query = '(' + fields.map { |field| "(#{@klass.table_name}.#{field} like ?)" }.join(" OR ") + ')'
+                field_query = '(' + fields.map { |field| "(#{@klass.table_name+'.' unless field.to_s.index('.')}#{field} #{match_keyword} ?)" }.join(" OR ") + ')'
                 args += ["%#{word}%"] * fields.length
                 field_query
               end
@@ -305,32 +315,35 @@ module Hobo
       def exists_sql_condition(reflection, any=false)
         owner = @klass
         owner_primary_key = "#{owner.table_name}.#{owner.primary_key}"
+ 
         if reflection.options[:through]
           join_table   = reflection.through_reflection.klass.table_name
           owner_fkey   = reflection.through_reflection.primary_key_name
+          conditions   = reflection.options[:conditions].blank? ? '' : " AND #{reflection.through_reflection.klass.send(:sanitize_sql_for_conditions, reflection.options[:conditions])}"
+ 
           if any
-            "EXISTS (SELECT * FROM #{join_table} WHERE #{join_table}.#{owner_fkey} = #{owner_primary_key})"
+            "EXISTS (SELECT * FROM #{join_table} WHERE #{join_table}.#{owner_fkey} = #{owner_primary_key}#{conditions})"
           else
             source_fkey  = reflection.source_reflection.primary_key_name
             "EXISTS (SELECT * FROM #{join_table} " +
-              "WHERE #{join_table}.#{source_fkey} = ? AND #{join_table}.#{owner_fkey} = #{owner_primary_key})"
+              "WHERE #{join_table}.#{source_fkey} = ? AND #{join_table}.#{owner_fkey} = #{owner_primary_key}#{conditions})"
           end
         else
           foreign_key = reflection.primary_key_name
           related     = reflection.klass
-
+          conditions = reflection.options[:conditions].blank? ? '' : " AND #{reflection.klass.send(:sanitize_sql_for_conditions, reflection.options[:conditions])}"
+ 
           if any
             "EXISTS (SELECT * FROM #{related.table_name} " +
-              "WHERE #{related.table_name}.#{foreign_key} = #{owner_primary_key})"
+              "WHERE #{related.table_name}.#{foreign_key} = #{owner_primary_key}#{conditions})"
           else
             "EXISTS (SELECT * FROM #{related.table_name} " +
               "WHERE #{related.table_name}.#{foreign_key} = #{owner_primary_key} AND " +
-              "#{related.table_name}.#{related.primary_key} = ?)"
+              "#{related.table_name}.#{related.primary_key} = ?#{conditions})"
           end
         end
       end
 
-
       def find_if_named(reflection, string_or_record)
         if string_or_record.is_a?(String)
           name = string_or_record

data/lib/hobo/scopes/named_scope_extensions.rb

@@ -1,39 +1,27 @@
 module ActiveRecord
   module NamedScope
-    
-    class Scope      
-      delegate :member_class, :to => :proxy_found      
-      include Hobo::Scopes::ApplyScopes      
-    end
+    class Scope
 
-    module ClassMethods
-      def scopes
-        hash = read_inheritable_attribute(:scopes)
-        if hash.nil?
-          if respond_to?(:create_automatic_scope)
-            write_inheritable_attribute(:scopes, new_automatic_scoping_hash(self))
-          else
-            # add a default_proc to optimize the next condition
-            write_inheritable_attribute(:scopes, Hash.new { |hash, key| nil })
-          end
-        elsif hash.default_proc.nil? && respond_to?(:create_automatic_scope)
-          write_inheritable_attribute(:scopes, new_automatic_scoping_hash(self).merge!(hash))
-        else
-          hash
-        end
-      end
+      delegate :member_class, :to => :proxy_found
 
-      private
+      include Hobo::Scopes::ApplyScopes
 
-      def new_automatic_scoping_hash(o)
-        hash = Hash.new { |hash, key| o.create_automatic_scope(key) && hash[key] }
-        hash.meta_eval do
-          define_method :include? do |key, *args|
-            super(key, *args) || o.create_automatic_scope(key)
+      def respond_to?(method, include_private=false)
+        super || scopes.include?(method) || proxy_scope.respond_to?(method, include_private)
+      end
+      
+      private
+      
+      def method_missing(method, *args, &block)
+        if respond_to?(method) && scopes.include?(method)
+          scopes[method].call(self, *args)
+        else
+          with_scope :find => proxy_options do
+            proxy_scope.send(method, *args, &block)
           end
         end
-        hash
       end
+
     end
   end
 end