hobo 0.8.2 → 0.8.3

data/lib/hobo/hobo_helper.rb

@@ -61,7 +61,9 @@ module Hobo
       if obj.respond_to?(:member_class)
         # Asking for URL of a collection, e.g. category/1/adverts or category/1/adverts/new
         
-        owner_name = obj.origin.class.reverse_reflection(obj.origin_attribute).name.to_s
+        refl = obj.origin.class.reverse_reflection(obj.origin_attribute)
+        owner_name = refl.name.to_s
+        owner_name = owner_name.singularize if refl.macro == :has_many
         if action == :new
           action_path = "#{obj.origin_attribute}/new"
           action = :"new_for_#{owner_name}"
@@ -154,25 +156,39 @@ module Hobo
       # TODO: Calls to respond_to? in here can cause the full collection hiding behind a scoped collection to get loaded
       res = []
       empty = true
-      if enum.respond_to?(:each_pair)
-        enum.each_pair do |key, value|
-          empty = false;
-          self.this_key = key;
-          new_object_context(value) { res << yield }
-        end
-      else
-        enum.each do |e|
-          empty = false;
-          if e.respond_to?(:new_record?) && !e.new_record?
-            new_field_context(e.id.to_s, e) { res << yield }
-          else
-            new_object_context(e) { res << yield }
+      scope.new_scope(:repeat_collection => enum) do
+        if enum.respond_to?(:each_pair)
+          enum.each_pair do |key, value|
+            empty = false;
+            self.this_key = key;
+            new_object_context(value) { res << yield }
+          end
+        else
+          index = 0
+          enum.each do |e|
+            empty = false;
+            if enum == this
+              new_field_context(index, e) { res << yield }
+            else
+              new_object_context(e) { res << yield }
+            end
+            index += 1
           end
         end
+        Dryml.last_if = !empty
       end
-      Dryml.last_if = !empty
       res
     end
+    
+    
+    def first_item?
+      this == scope.repeat_collection.first
+    end
+    
+    
+    def last_item?
+      this == scope.repeat_collection.last
+    end
 
 
     def comma_split(x)

data/lib/hobo/include_in_save.rb

@@ -16,13 +16,21 @@ module Hobo
     def validate_included_in_save
       if included_in_save
         included_in_save._?.each_pair do |association, records|
+          added = false
           records.each do |record|
-            errors.add association, "is invalid" unless record.valid?
+            # we want to call valid? on each one, but only add the error to self once
+            unless record.valid?
+              unless added
+                errors.add association, "..."
+                added = true
+              end
+            end
           end
         end
       end
     end
 
+
     def save_included
       if included_in_save
         included_in_save.each_pair do |association, records|

data/lib/hobo/lifecycles.rb

@@ -1,5 +1,3 @@
-%w[lifecycle actions creator state transition].each { |lib| require "hobo/lifecycles/#{lib}" }
-
 module Hobo
 
   module Lifecycles
@@ -47,11 +45,6 @@ module Hobo
         @lifecycle ||= self.class::Lifecycle.new(self)
       end
 
-
-      def become(state)
-        self.lifecycle.become state
-      end
-
     end
 
 

data/lib/hobo/lifecycles/creator.rb

@@ -50,7 +50,7 @@ module Hobo
 
       def change_state(record)
         state = options[:become]
-        record.become(state) if state
+        record.lifecycle.become(state) if state
       end
 
 

data/lib/hobo/lifecycles/lifecycle.rb

@@ -27,7 +27,7 @@ module Hobo
         name = name.to_s
         returning(State.new(name, on_enter)) do |s|
           states[name] = s
-          class_eval "def #{name}?; record.state == '#{name}'; end"
+          class_eval "def #{name}_state?; state_name == '#{name}' end"
         end
       end
 
@@ -74,7 +74,10 @@ module Hobo
 
 
       def self.create(name, user, attributes=nil)
-        creators[name.to_s].run!(user, attributes)
+        creator = creators[name.to_s]
+        record = creator.run!(user, attributes)
+        record.lifecycle.active_step = creator
+        record
       end
 
 
@@ -97,7 +100,7 @@ module Hobo
 
       attr_reader :record
 
-      attr_accessor :provided_key
+      attr_accessor :provided_key, :active_step
 
 
       def initialize(record)
@@ -112,6 +115,7 @@ module Hobo
 
       def transition(name, user, attributes=nil)
         transition = find_transition(name, user, attributes)
+        self.active_step = transition
         transition.run!(record, user, attributes)
       end
 
@@ -157,6 +161,7 @@ module Hobo
             raise ArgumentError, "No such state '#{state_name}' for #{record.class.name}" unless s
             if record.save(validate)
               s.activate! record
+              self.active_step = nil # That's the end of this step
               true
             else
               false

data/lib/hobo/mass_assignment.rb

@@ -0,0 +1,64 @@
+module Hobo
+  
+  MassAssignment = classy_module do
+    
+    include IncludeInSave
+    
+    
+    # --- has_many mass assignment support --- #
+    
+    def self.has_many_with_mass_assignment(name, options={}, &block)
+      accessible = options.delete(:accessible)
+      has_many_without_mass_assignment(name, options, &block)
+      
+      if accessible
+        class_eval %{
+          def #{name}_with_mass_assignment=(array_or_hash)
+            items = prepare_has_many_assignment(:#{name}, array_or_hash)
+            self.#{name}_without_mass_assignment = items
+            # ensure the loaded array contains any changed records
+            self.#{name}.proxy_target[0..-1] = items
+          end}, __FILE__, __LINE__ - 3
+        alias_method_chain :"#{name}=", :mass_assignment
+      end
+    end
+    metaclass.alias_method_chain :has_many, :mass_assignment
+    
+    
+    def prepare_has_many_assignment(association_name, array_or_hash)
+      association = send(association_name)
+
+      array = params_hash_to_array(array_or_hash)
+      array.map do |record_or_hash|
+        if record_or_hash.is_a?(Hash)
+          hash = record_or_hash
+
+          id = hash.delete(:id)
+          record = if id
+                     association.find(id) # TODO: We don't really want to find these one by one
+                   else
+                     # Remove completely blank hashes
+                     next if hash.values.join.blank?
+
+                     record = association.build
+                   end
+          record.attributes = hash
+          include_in_save(association_name, record)
+        else
+          record = record_or_hash
+        end
+        record
+
+      end.compact
+
+    end      
+    
+    def params_hash_to_array(array_or_hash)
+      if array_or_hash.is_a?(Hash)
+        array = array_or_hash.get(*array_or_hash.keys.sort_by(&:to_i))
+      else
+        array_or_hash
+      end
+    end
+  end    
+end

data/lib/hobo/model.rb

@@ -29,7 +29,7 @@ module Hobo
 
         include Hobo::Lifecycles::ModelExtensions
         include Hobo::FindFor
-        include Hobo::IncludeInSave
+        include Hobo::MassAssignment
       end
 
       class << base
@@ -246,7 +246,7 @@ module Hobo
 
 
       def has_one_with_new_method(name, options={}, &block)
-        has_one_without_new_method(name, options)
+        has_one_without_new_method(name, options, &block)
         class_eval "def new_#{name}(attributes={}); build_#{name}(attributes, false); end"
       end
 
@@ -321,21 +321,39 @@ module Hobo
       end
 
 
-      # FIXME: This should really be a method on AssociationReflection
       def reverse_reflection(association_name)
         refl = reflections[association_name.to_sym] or raise "No reverse reflection for #{name}.#{association_name}"
         return nil if refl.options[:conditions] || refl.options[:polymorphic]
-
-        reverse_macro = if refl.macro == :has_many
-                          :belongs_to
-                        elsif refl.macro == :belongs_to
-                          :has_many
-                        end
-        refl.klass.reflections.values.find do |r|
-          r.macro == reverse_macro &&
-            r.klass == self &&
-            !r.options[:conditions] &&
-            r.primary_key_name == refl.primary_key_name
+        
+        if refl.macro == :has_many && (self_to_join = refl.through_reflection)
+          # Find the reverse of a has_many :through (another has_many :through)
+          
+          join_to_self  = reverse_reflection(self_to_join.name)
+          join_to_other = refl.source_reflection
+          other_to_join = self_to_join.klass.reverse_reflection(join_to_other.name)
+          
+          return nil if self_to_join.options[:conditions] || join_to_other.options[:conditions]
+          
+          refl.klass.reflections.values.find do |r|
+            r.macro == :has_many &&
+              !r.options[:conditions] &&
+              r.through_reflection == other_to_join && 
+              r.source_reflection  == join_to_self
+          end
+        else
+          # Find the :belongs_to that corresponds to a :has_many or vice versa
+          
+          reverse_macro = if refl.macro == :has_many
+                            :belongs_to
+                          elsif refl.macro == :belongs_to
+                            :has_many
+                          end
+          refl.klass.reflections.values.find do |r|
+            r.macro == reverse_macro &&
+              r.klass == self &&
+              !r.options[:conditions] &&
+              r.primary_key_name == refl.primary_key_name
+          end
         end
       end
 
@@ -385,6 +403,7 @@ module Hobo
 
     include Scopes
 
+
     def to_url_path
       "#{self.class.to_url_path}/#{to_param}" unless new_record?
     end
@@ -396,7 +415,7 @@ module Hobo
         readable = name.to_s.downcase.gsub(/[^a-z0-9]+/, '-').gsub(/-+$/, '').gsub(/^-+$/, '').split('-')[0..5].join('-')
         @to_param ||= "#{id}-#{readable}"
       else
-        id
+        id.to_s
       end
     end
 
@@ -581,7 +600,12 @@ module Hobo
 
       elsif field_type <= Date
         if value.is_a? Hash
-          Date.new(*(%w{year month day}.map{|s| value[s].to_i}))
+          parts = %w{year month day}.map{|s| value[s].to_i}
+          if parts.include?(0)
+            nil
+          else
+            Date.new(*parts)
+          end
         elsif value.is_a? String
           dt = parse_datetime(value)
           dt && dt.to_date
@@ -623,7 +647,7 @@ module Hobo
 
 
     def convert_collection_for_mass_assignment(reflection, value)
-      klass = reflection.safe_class
+      klass = reflection.klass
       if klass.try.name_attribute && value.is_a?(Array)
         value.map do |x|
           if x.is_a?(String)

data/lib/hobo/model_controller.rb

@@ -26,6 +26,7 @@ module Hobo
 
           helper_method :model, :current_user
           before_filter :set_no_cache_headers
+          after_filter  :remember_page_path
 
           rescue_from ActiveRecord::RecordNotFound, :with => :not_found
 
@@ -82,14 +83,19 @@ module Hobo
     module ClassMethods
 
       attr_writer :model
-
+      
+      def model_name
+        name.sub(/Controller$/, "").singularize
+      end
+      
       def model
-        @model ||= name.sub(/Controller$/, "").singularize.constantize
+        @model ||= model_name.constantize
       end
 
 
-      def autocomplete(name, options={}, &block)
-        options = options.dup
+      def autocomplete(*args, &block)
+        options = args.extract_options!
+        name = args.first || model.name_attribute
         field = options.delete(:field) || name
         if block
           index_action "complete_#{name}", &block
@@ -223,19 +229,46 @@ module Hobo
       end
       
       
+      def creator_page_action(name, options={}, &block)
+        define_method(name) do
+          creator_page_action name, options, &block
+        end
+      end
+
+
+      def do_creator_action(name, options={}, &block)
+        define_method("do_#{name}") do
+          do_creator_action name, options, &block
+        end
+      end
+      
+
+      def transtion_page_action(name, options={}, &block)
+        define_method(name) do
+          transtion_page_action name, options, &block
+        end
+      end
+
+
+      def do_transition_action(name, options={}, &block)
+        define_method("do_#{name}") do
+          do_transition_action name, options, &block
+        end
+      end
+
+      
       def auto_actions_for(owner, actions)
-        model.reverse_reflection(owner)._?.klass == model or 
-          raise ArgumentError, "Invalid owner association '#{owner}' for #{model}"
+        name = model.reflections[owner].macro == :has_many ? owner.to_s.singularize : owner
         
         owner_actions[owner] ||= []
         Array(actions).each do |action|
           case action
           when :new
-            define_method("new_for_#{owner}")    { hobo_new_for owner }
+            define_method("new_for_#{name}")    { hobo_new_for owner }
           when :index
-            define_method("index_for_#{owner}")  { hobo_index_for owner }
+            define_method("index_for_#{name}")  { hobo_index_for owner }
           when :create
-            define_method("create_for_#{owner}") { hobo_create_for owner }
+            define_method("create_for_#{name}") { hobo_create_for owner }
           else
             raise ArgumentError, "Invalid owner action: #{action}"
           end
@@ -332,13 +365,11 @@ module Hobo
     end
 
 
-    def destination_after_submit(record=nil, destroyed=false)
-      record ||= this
-
+    def destination_after_submit(record=this, destroyed=false)
       after_submit = params[:after_submit]
 
       # The after_submit post parameter takes priority
-      (after_submit == "stay-here" ? :back : after_submit) ||
+      (after_submit == "stay-here" ? session[:previous_page_path] : after_submit) ||
 
         # Then try the record's show page
         (!destroyed && object_url(@this)) ||
@@ -355,7 +386,18 @@ module Hobo
     
     
     def redirect_after_submit(*args)
-      redirect_to destination_after_submit(*args)
+      options = args.extract_options!
+      o = options[:redirect]
+      if o
+        url = if o.is_a?(Symbol)
+                object_url(this, o)
+              else
+                object_url(*Array(o))
+              end
+        redirect_to url
+      else
+        redirect_to destination_after_submit(*args)
+      end
     end
     
 
@@ -395,7 +437,7 @@ module Hobo
       klass = refl.klass
       id = params["#{klass.name.underscore}_id"]
       owner = klass.find(id)
-      instance_variable_set("@#{owner_association}", owner)
+      instance_variable_set("@#{owner.class.name.underscore}", owner)
       [owner, owner.send(model.reverse_reflection(owner_association).name)]
     end
 
@@ -475,13 +517,13 @@ module Hobo
     
 
 
-    def create_response(new_action, &b)
+    def create_response(new_action, options={}, &b)
       flash[:notice] = "The #{@this.class.name.titleize.downcase} was created successfully" if !request.xhr? && valid?
 
       response_block(&b) or
         if valid?
           respond_to do |wants|
-            wants.html { redirect_after_submit }
+            wants.html { redirect_after_submit(options) }
             wants.js   { hobo_ajax_response || render(:nothing => true) }
           end
         else
@@ -506,18 +548,18 @@ module Hobo
       @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, &b)
+      update_response(in_place_edit_field, options, &b)
     end
 
 
-    def update_response(in_place_edit_field=nil, &b)
+    def update_response(in_place_edit_field=nil, options={}, &b)
       flash[:notice] = "Changes to the #{@this.class.name.titleize.downcase} were saved" if !request.xhr? && valid?
 
       response_block(&b) or
         if valid?
           respond_to do |wants|
             wants.html do
-              redirect_after_submit
+              redirect_after_submit options
             end
             wants.js do
               if in_place_edit_field
@@ -552,10 +594,10 @@ module Hobo
     end
 
 
-    def destroy_response(&b)
+    def destroy_response(options={}, &b)
       response_block(&b) or
         respond_to do |wants|
-          wants.html { redirect_after_submit(this, true) }
+          wants.html { redirect_after_submit(this, true, options) }
           wants.js   { hobo_ajax_response || render(:nothing => true) }
         end
     end
@@ -563,12 +605,12 @@ module Hobo
 
     # --- Lifecycle Actions --- #
 
-    def do_creator_action(name, &b)
+    def do_creator_action(name, options={}, &b)
       @creator = model::Lifecycle.creators[name.to_s]
       self.this = @creator.run!(current_user, attribute_parameters)
       response_block(&b) or
         if valid?
-          redirect_after_submit
+          redirect_after_submit options
         else
           re_render_form(name)
         end
@@ -577,6 +619,7 @@ module Hobo
 
     def creator_page_action(name)
       self.this = model.new
+      this.exempt_from_edit_checks = true
       @creator = model::Lifecycle.creators[name.to_s] or raise ArgumentError, "No such creator in lifecycle: #{name}"
     end
 
@@ -592,11 +635,12 @@ module Hobo
 
 
     def do_transition_action(name, *args, &b)
+      options = args.extract_options!
       prepare_for_transition(name)
       @transition.run!(this, current_user, attribute_parameters)
       response_block(&b) or
         if valid?
-          redirect_after_submit
+          redirect_after_submit options
         else
           re_render_form(name)
         end
@@ -705,6 +749,13 @@ module Hobo
       headers["Expires"] ='0'
     end
 
+    def remember_page_path
+      if request.method == :get
+        session[:previous_page_path] = request.path
+        session[:previous_page_path] += "?#{request.query_string}" unless request.query_string.blank?
+      end
+    end
+
     # --- end filters --- #
 
     public