activerecord 1.5.1 → 1.6.0

data/CHANGELOG

@@ -1,3 +1,37 @@
+*1.6.0* (January 25th, 2005)
+
+* Added that has_many association build and create methods can take arrays of record data like Base#create and Base#build to build/create multiple records at once.
+
+* Added that Base#delete and Base#destroy both can take an array of ids to delete/destroy #336
+
+* Added the option of supplying an array of attributes to Base#create, so that multiple records can be created at once.
+
+* Added the option of supplying an array of ids and attributes to Base#update, so that multiple records can be updated at once (inspired by #526/Duane Johnson). Example
+
+    people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy"} }
+    Person.update(people.keys, people.values)
+
+* Added ActiveRecord::Base.timestamps_gmt that can be set to true to make the automated timestamping use GMT instead of local time #520 [Scott Baron]
+
+* Added that update_all calls sanitize_sql on its updates argument, so stuff like MyRecord.update_all(['time = ?', Time.now]) works #519 [notahat]
+
+* Fixed that the dynamic finders didn't treat nil as a "IS NULL" but rather "= NULL" case #515 [Demetrius]
+
+* Added bind-named arrays for interpolating a group of ids or strings in conditions #528 [bitsweat]
+
+* Added that has_and_belongs_to_many associations with additional attributes also can be created between unsaved objects and only committed to the database when Base#save is called on the associator #524 [Eric Anderson]
+
+* Fixed that records fetched with piggy-back attributes or through rich has_and_belongs_to_many associations couldn't be saved due to the extra attributes not part of the table #522 [Eric Anderson]
+
+* Added mass-assignment protection for the inheritance column -- regardless of a custom column is used or not
+
+* Fixed that association proxies would fail === tests like PremiumSubscription === @account.subscription
+
+* Fixed that column aliases didn't work as expected with the new MySql411 driver #507 [Demetrius]
+
+* Fixed that find_all would produce invalid sql when called sequentialy #490 [Scott Baron]
+
+
 *1.5.1* (January 18th, 2005)
 
 * Fixed that the belongs_to and has_one proxy would fail a test like 'if project.manager' -- this unfortunately also means that you can't call methods like project.manager.build unless there already is a manager on the project #492 [Tim Bates]

data/install.rb

@@ -18,7 +18,7 @@ unless $sitedir
   end
 end
 
-makedirs = %w{ active_record/associations active_record/connection_adapters active_record/support active_record/vendor active_record/acts }
+makedirs = %w{ active_record/associations active_record/connection_adapters active_record/support active_record/vendor active_record/acts active_record/support/core_ext active_record/support/core_ext/hash active_record/support/core_ext/numeric active_record/support/core_ext/string }
 makedirs.each {|f| File::makedirs(File.join($sitedir, *f.split(/\//)))}
 
 # deprecated files that should be removed
@@ -50,8 +50,18 @@ files = %w-
  active_record/support/class_attribute_accessors.rb
  active_record/support/class_inheritable_attributes.rb
  active_record/support/clean_logger.rb
+ active_record/support/core_ext/hash/keys.rb
+ active_record/support/core_ext/hash.rb
+ active_record/support/core_ext/object_and_class.rb
+ active_record/support/core_ext/numeric/bytes.rb
+ active_record/support/core_ext/numeric/time.rb
+ active_record/support/core_ext/numeric.rb
+ active_record/support/core_ext/string/inflections.rb
+ active_record/support/core_ext/string.rb
+ active_record/support/core_ext.rb
  active_record/support/inflector.rb
  active_record/support/misc.rb
+ active_record/support/module_attribute_accessors.rb
  active_record/timestamp.rb
  active_record/transactions.rb
  active_record/validations.rb

data/lib/active_record/associations.rb

@@ -35,7 +35,6 @@ module ActiveRecord
     # The project class now has the following methods (and more) to ease the traversal and manipulation of its relationships:
     # * <tt>Project#portfolio, Project#portfolio=(portfolio), Project#portfolio.nil?</tt>
     # * <tt>Project#project_manager, Project#project_manager=(project_manager), Project#project_manager.nil?,</tt>
-    #   <tt>Project#project_manager.build, Project#project_manager.create</tt>
     # * <tt>Project#milestones.empty?, Project#milestones.size, Project#milestones, Project#milestones<<(milestone),</tt>
     #   <tt>Project#milestones.delete(milestone), Project#milestones.find(milestone_id), Project#milestones.find_all(conditions),</tt>
     #   <tt>Project#milestones.build, Project#milestones.create</tt>
@@ -249,9 +248,11 @@ module ActiveRecord
       #   and saves the associate object.
       # * <tt>association.nil?</tt> - returns true if there is no associated object.
       # * <tt>association.build(attributes = {})</tt> - returns a new object of the associated type that has been instantiated
-      #   with +attributes+ and linked to this object through a foreign key but has not yet been saved.
+      #   with +attributes+ and linked to this object through a foreign key but has not yet been saved. Note: This ONLY works if
+      #   an association already exists. It will NOT work if the association is nil.
       # * <tt>association.create(attributes = {})</tt> - returns a new object of the associated type that has been instantiated
       #   with +attributes+ and linked to this object through a foreign key and that has already been saved (if it passed the validation).
+      #   Note: This ONLY works if an association already exists. It will NOT work if the association is nil.
       #
       # Example: An Account class declares <tt>has_one :beneficiary</tt>, which will add:
       # * <tt>Account#beneficiary</tt> (similar to <tt>Beneficiary.find_first "account_id = #{id}"</tt>)

data/lib/active_record/associations/association_collection.rb

@@ -53,9 +53,13 @@ module ActiveRecord
       
       def create(attributes = {})
         # Can't use Base.create since the foreign key may be a protected attribute.
-        record = build(attributes)
-        record.save unless @owner.new_record?
-        record
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr) }
+        else
+          record = build(attributes)
+          record.save unless @owner.new_record?
+          record
+        end
       end
 
       # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been loaded and

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -81,8 +81,8 @@ module ActiveRecord
 
       def push_with_attributes(record, join_attributes = {})
         raise_on_type_mismatch(record)
-        insert_record_with_join_attributes(record, join_attributes)
-        join_attributes.each { |key, value| record.send(:write_attribute, key, value) }
+        join_attributes.each { |key, value| record[key.to_s] = value }
+        insert_record(record) unless @owner.new_record?
         @target << record
         self
       end
@@ -105,22 +105,33 @@ module ActiveRecord
 
         def insert_record(record)
           return false unless record.save
+
           if @options[:insert_sql]
             @owner.connection.execute(interpolate_sql(@options[:insert_sql], record))
           else
-            sql = "INSERT INTO #{@join_table} (#{@association_class_primary_key_name}, #{@association_foreign_key}) " + 
-                  "VALUES (#{@owner.quoted_id},#{record.quoted_id})"
+            columns = @owner.connection.columns(@join_table, "#{@join_table} Columns")
+
+            attributes = columns.inject({}) do |attributes, column|
+              case column.name
+                when @association_class_primary_key_name
+                  attributes[column.name] = @owner.quoted_id
+                when @association_foreign_key
+                  attributes[column.name] = record.quoted_id
+                else
+                  value = record[column.name]
+                  attributes[column.name] = value unless value.nil?
+              end
+              attributes
+            end
+
+            sql =
+              "INSERT INTO #{@join_table} (#{@owner.send(:quoted_column_names, attributes).join(', ')}) " +
+              "VALUES (#{attributes.values.collect { |value| @owner.send(:quote, value) }.join(', ')})"
+
             @owner.connection.execute(sql)
           end
-          true
-        end
-        
-        def insert_record_with_join_attributes(record, join_attributes)
-          attributes = { @association_class_primary_key_name => @owner.id, @association_foreign_key => record.id }.update(join_attributes)
-          sql = 
-            "INSERT INTO #{@join_table} (#{@owner.send(:quoted_column_names, attributes).join(', ')}) " +
-            "VALUES (#{attributes.values.collect { |value| @owner.send(:quote, value) }.join(', ')})"
-          @owner.connection.execute(sql)
+          
+          return true
         end
         
         def delete_records(records)

data/lib/active_record/associations/has_many_association.rb

@@ -9,18 +9,22 @@ module ActiveRecord
       end
 
       def build(attributes = {})
-        load_target
-        record = @association_class.new(attributes)
-        record[@association_class_primary_key_name] = @owner.id unless @owner.new_record?
-        @target << record
-        record
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr) }
+        else
+          load_target
+          record = @association_class.new(attributes)
+          record[@association_class_primary_key_name] = @owner.id unless @owner.new_record?
+          @target << record
+          record
+        end
       end
 
       def find_all(runtime_conditions = nil, orderings = nil, limit = nil, joins = nil)
         if @options[:finder_sql]
           records = @association_class.find_by_sql(@finder_sql)
         else
-          sql = @finder_sql
+          sql = @finder_sql.dup
           sql << " AND #{sanitize_sql(runtime_conditions)}" if runtime_conditions
           orderings ||= @options[:order]
           records = @association_class.find_all(sql, orderings, limit, joins)

data/lib/active_record/base.rb

@@ -124,11 +124,11 @@ module ActiveRecord #:nodoc:
   #   user = User.create("preferences" => { "background" => "black", "display" => large })
   #   User.find(user.id).preferences # => { "background" => "black", "display" => large }
   # 
-  # You can also specify an optional :class_name option that'll raise an exception if a serialized object is retrieved as a 
+  # You can also specify an class option as the second parameter that'll raise an exception if a serialized object is retrieved as a 
   # descendent of a class not in the hierarchy. Example:
   # 
   #   class User < ActiveRecord::Base
-  #     serialize :preferences, :class_name => "Hash"
+  #     serialize :preferences, Hash
   #   end
   # 
   #   user = User.create("preferences" => %w( one two three ))
@@ -171,8 +171,7 @@ module ActiveRecord #:nodoc:
   # * +AdapterNotSpecified+ -- the <tt>:adapter</tt> key used in <tt>establish_connection</tt> specified an unexisting adapter
   #   (or a bad spelling of an existing one). 
   # * +AssociationTypeMismatch+ -- the object assigned to the association wasn't of the type specified in the association definition. 
-  # * +SerializationTypeMismatch+ -- the object serialized wasn't of the class specified in the <tt>:class_name</tt> option of 
-  #   the serialize definition. 
+  # * +SerializationTypeMismatch+ -- the object serialized wasn't of the class specified as the second parameter. 
   # * +ConnectionNotEstablished+ -- no connection has been established. Use <tt>establish_connection</tt> before querying.
   # * +RecordNotFound+ -- no record responded to the find* method. 
   #   Either the row with the given ID doesn't exist or the row didn't meet the additional restrictions.
@@ -289,7 +288,7 @@ module ActiveRecord #:nodoc:
             if result.size == ids.size
               result
             else
-              raise RecordNotFound, "Couldn't find #{name} with ID in (#{ids_list})#{conditions}"
+              raise RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids_list})#{conditions}"
             end
         end
       end
@@ -340,39 +339,49 @@ module ActiveRecord #:nodoc:
       # Creates an object, instantly saves it as a record (if the validation permits it), and returns it. If the save
       # fail under validations, the unsaved object is still returned.
       def create(attributes = nil)
-        object = new(attributes)
-        object.save
-        object
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr) }
+        else
+          object = new(attributes)
+          object.save
+          object
+        end
       end
 
       # Finds the record from the passed +id+, instantly saves it with the passed +attributes+ (if the validation permits it), 
       # and returns it. If the save fail under validations, the unsaved object is still returned.
       def update(id, attributes)
-        object = find(id)
-        object.attributes = attributes
-        object.save
-        object
+        if id.is_a?(Array)
+          idx = -1
+          id.collect { |id| idx += 1; update(id, attributes[idx]) }
+        else
+          object = find(id)
+          object.update_attributes(attributes)
+          object
+        end
       end
 
-      # Deletes the record with the given +id+ without instantiating an object first.
+      # Deletes the record with the given +id+ without instantiating an object first. If an array of ids is provided, all of them
+      # are deleted.
       def delete(id)
-        delete_all([ "#{primary_key} = ?", id ])
+        delete_all([ "#{primary_key} IN (?)", id ])
       end
       
       # Destroys the record with the given +id+ by instantiating the object and calling #destroy (all the callbacks are the triggered).
+      # If an array of ids is provided, all of them are destroyed.
       def destroy(id)
-        find(id).destroy
+        id.is_a?(Array) ? id.each { |id| destroy(id) } : find(id).destroy
       end
 
       # Updates all records with the SET-part of an SQL update statement in +updates+ and returns an integer with the number of rows updates.
       # A subset of the records can be selected by specifying +conditions+. Example:
       #   Billing.update_all "category = 'authorized', approved = 1", "author = 'David'"
       def update_all(updates, conditions = nil)
-        sql  = "UPDATE #{table_name} SET #{updates} "
+        sql  = "UPDATE #{table_name} SET #{sanitize_sql(updates)} "
         add_conditions!(sql, conditions)
         return connection.update(sql, "#{name} Update")
       end
-    
+
       # Destroys the objects for all the records that matches the +condition+ by instantiating each object and calling
       # the destroy method. Example:
       #   Person.destroy_all "last_login < '2004-04-04'"
@@ -598,6 +607,11 @@ module ActiveRecord #:nodoc:
         return result
       end
 
+      # Overwrite the default class equality method to provide support for association proxies.
+      def ===(object)
+        object.is_a?(self)
+      end
+
       private
         # Finder methods must instantiate through this method to work with the single-table inheritance model
         # that makes it possible to create objects of different types from the same table.
@@ -663,7 +677,9 @@ module ActiveRecord #:nodoc:
           if method_name =~ /find_(all_by|by)_([_a-z]+)/
             finder, attributes = ($1 == "all_by" ? :find_all : :find_first), $2.split("_and_")
             attributes.each { |attr_name| super unless column_methods_hash[attr_name.intern] }
-            conditions = attributes.collect { |attr_name| "#{attr_name} = ? "}.join(" AND ")
+
+            attr_index = -1
+            conditions = attributes.collect { |attr_name| attr_index += 1; "#{attr_name} #{arguments[attr_index] ? "=" : "IS"} ? " }.join(" AND ")
             send(finder, [conditions, *arguments[0...attributes.length]], *arguments[attributes.length..-1])
           else
             super
@@ -716,7 +732,7 @@ module ActiveRecord #:nodoc:
         def replace_bind_variables(statement, values)
           raise_if_bind_arity_mismatch(statement, statement.count('?'), values.size)
           bound = values.dup
-          statement.gsub('?') { connection.quote(bound.shift) }
+          statement.gsub('?') { quote_bound_value(bound.shift) }
         end
 
         def replace_named_bind_variables(statement, bind_vars)
@@ -724,13 +740,22 @@ module ActiveRecord #:nodoc:
           statement.gsub(/:(\w+)/) do
             match = $1.to_sym
             if bind_vars.has_key?(match)
-              connection.quote(bind_vars[match])
+              quote_bound_value(bind_vars[match])
             else
               raise PreparedStatementInvalid, "missing value for :#{match} in #{statement}"
             end
           end
         end
 
+        def quote_bound_value(value)
+          case value
+            when Array
+              value.map { |v| connection.quote(v) }.join(',')
+            else
+              connection.quote(value)
+          end
+        end
+
         def raise_if_bind_arity_mismatch(statement, expected, provided)
           unless expected == provided
             raise PreparedStatementInvalid, "wrong number of bind variables (#{provided} for #{expected}) in: #{statement}"
@@ -1093,22 +1118,30 @@ module ActiveRecord #:nodoc:
 
       def remove_attributes_protected_from_mass_assignment(attributes)
         if self.class.accessible_attributes.nil? && self.class.protected_attributes.nil?
-          attributes.reject { |key, value| key == self.class.primary_key }
+          attributes.reject { |key, value| attributes_protected_by_default.include?(key) }
         elsif self.class.protected_attributes.nil?
-          attributes.reject { |key, value| !self.class.accessible_attributes.include?(key.intern) || key == self.class.primary_key }
+          attributes.reject { |key, value| !self.class.accessible_attributes.include?(key.intern) || attributes_protected_by_default.include?(key) }
         elsif self.class.accessible_attributes.nil?
-          attributes.reject { |key, value| self.class.protected_attributes.include?(key.intern) || key == self.class.primary_key }
+          attributes.reject { |key, value| self.class.protected_attributes.include?(key.intern) || attributes_protected_by_default.include?(key) }
         end
       end
 
+      # The primary key and inheritance column can never be set by mass-assignment for security reasons.
+      def attributes_protected_by_default
+        [ self.class.primary_key, self.class.inheritance_column ]
+      end
+
       # Returns copy of the attributes hash where all the values have been safely quoted for use in
       # an SQL statement. 
       def attributes_with_quotes(include_primary_key = true)
         columns_hash = self.class.columns_hash
-        @attributes.inject({}) do |attrs_quoted, pair| 
+
+        attrs_quoted = @attributes.inject({}) do |attrs_quoted, pair| 
           attrs_quoted[pair.first] = quote(pair.last, columns_hash[pair.first]) unless !include_primary_key && pair.first == self.class.primary_key
           attrs_quoted
         end
+
+        attrs_quoted.delete_if { |key, value| !self.class.columns_hash.keys.include?(key) }
       end
       
       # Quote strings appropriately for SQL statements.
@@ -1167,7 +1200,7 @@ module ActiveRecord #:nodoc:
 
           unless value.empty?
             attributes[attribute_name] << 
-              [find_parameter_position(multiparameter_name), type_cast_attribute_value(multiparameter_name, value)]
+              [ find_parameter_position(multiparameter_name), type_cast_attribute_value(multiparameter_name, value) ]
           end
         end
 
@@ -1192,10 +1225,10 @@ module ActiveRecord #:nodoc:
       end
 
       def quote_columns(column_quoter, hash)
-        hash.inject({}) {|list, pair|
+        hash.inject({}) do |list, pair|
           list[column_quoter.quote_column_name(pair.first)] = pair.last
           list
-        }
+        end
       end
 
       def quoted_comma_pair_list(column_quoter, hash)
@@ -1203,7 +1236,7 @@ module ActiveRecord #:nodoc:
       end
 
       def object_from_yaml(string)
-        return string unless String === string
+        return string unless string.is_a?(String)
         if has_yaml_encoding_header?(string)
           begin
             YAML::load(string)
@@ -1220,4 +1253,4 @@ module ActiveRecord #:nodoc:
         string[0..3] == "--- "
       end
   end
-end
+end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -217,21 +217,21 @@ module ActiveRecord
 
       private
         def string_to_date(string)
-          return string if Date === string
+          return string if string.is_a?(Date)
           date_array = ParseDate.parsedate(string)
           # treat 0000-00-00 as nil
           Date.new(date_array[0], date_array[1], date_array[2]) rescue nil
         end
         
         def string_to_time(string)
-          return string if Time === string
+          return string if string.is_a?(Time)
           time_array = ParseDate.parsedate(string).compact
           # treat 0000-00-00 00:00:00 as nil
           Time.send(Base.default_timezone, *time_array) rescue nil
         end
 
         def string_to_dummy_time(string)
-          return string if Time === string
+          return string if string.is_a?(Time)
           time_array = ParseDate.parsedate(string)
           # pad the resulting array with dummy date information
           time_array[0] = 2000; time_array[1] = 1; time_array[2] = 1;

data/lib/active_record/fixtures.rb

@@ -166,7 +166,7 @@ class Fixtures < Hash
         fixtures.each { |fixture| fixture.insert_fixtures }
       end
 
-      reset_sequences(connection, table_names) if ActiveRecord::ConnectionAdapters::PostgreSQLAdapter === connection
+      reset_sequences(connection, table_names) if connection.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
 
       return fixtures.size > 1 ? fixtures : fixtures.first
     ensure

data/lib/active_record/support/binding_of_caller.rb

@@ -1,85 +1,83 @@
-begin
-  require 'simplecc'
-rescue LoadError
-  class Continuation #:nodoc:
-    def self.create(*args, &block)
-      cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
-      result ||= args
-      return *[cc, *result]
-    end
-  end
-end
-
-class Binding #:nodoc:
-  # This method returns the binding of the method that called your
-  # method. It will raise an Exception when you're not inside a method.
-  #
-  # It's used like this:
-  #   def inc_counter(amount = 1)
-  #     Binding.of_caller do |binding|
-  #       # Create a lambda that will increase the variable 'counter'
-  #       # in the caller of this method when called.
-  #       inc = eval("lambda { |arg| counter += arg }", binding)
-  #       # We can refer to amount from inside this block safely.
-  #       inc.call(amount)
-  #     end
-  #     # No other statements can go here. Put them inside the block.
-  #   end
-  #   counter = 0
-  #   2.times { inc_counter }
-  #   counter # => 2
-  #
-  # Binding.of_caller must be the last statement in the method.
-  # This means that you will have to put everything you want to
-  # do after the call to Binding.of_caller into the block of it.
-  # This should be no problem however, because Ruby has closures.
-  # If you don't do this an Exception will be raised. Because of
-  # the way that Binding.of_caller is implemented it has to be
-  # done this way.
-  def self.of_caller(&block)
-    old_critical = Thread.critical
-    Thread.critical = true
-    count = 0
-    cc, result, error, extra_data = Continuation.create(nil, nil)
-    error.call if error
-
-    tracer = lambda do |*args|
-      type, context, extra_data = args[0], args[4], args
-      if type == "return"
-        count += 1
-        # First this method and then calling one will return --
-        # the trace event of the second event gets the context
-        # of the method which called the method that called this
-        # method.
-        if count == 2
-          # It would be nice if we could restore the trace_func
-          # that was set before we swapped in our own one, but
-          # this is impossible without overloading set_trace_func
-          # in current Ruby.
-          set_trace_func(nil)
-          cc.call(eval("binding", context), nil, extra_data)
-        end
-      elsif type == "line" then
-        nil
-      elsif type == "c-return" and extra_data[3] == :set_trace_func then
-        nil
-      else
-        set_trace_func(nil)
-        error_msg = "Binding.of_caller used in non-method context or " +
-          "trailing statements of method using it aren't in the block."
-        cc.call(nil, lambda { raise(ArgumentError, error_msg) }, nil)
-      end
-    end
-
-    unless result
-      set_trace_func(tracer)
-      return nil
-    else
-      Thread.critical = old_critical
-      case block.arity
-        when 1 then yield(result)
-        else yield(result, extra_data)        
-      end
-    end
-  end
-end
+begin
+  require 'simplecc'
+rescue LoadError
+  class Continuation; end # :nodoc: # for RDoc
+  def Continuation.create(*args, &block) # :nodoc:
+    cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
+    result ||= args
+    return *[cc, *result]
+  end
+end
+
+class Binding; end # for RDoc
+# This method returns the binding of the method that called your
+# method. It will raise an Exception when you're not inside a method.
+#
+# It's used like this:
+#   def inc_counter(amount = 1)
+#     Binding.of_caller do |binding|
+#       # Create a lambda that will increase the variable 'counter'
+#       # in the caller of this method when called.
+#       inc = eval("lambda { |arg| counter += arg }", binding)
+#       # We can refer to amount from inside this block safely.
+#       inc.call(amount)
+#     end
+#     # No other statements can go here. Put them inside the block.
+#   end
+#   counter = 0
+#   2.times { inc_counter }
+#   counter # => 2
+#
+# Binding.of_caller must be the last statement in the method.
+# This means that you will have to put everything you want to
+# do after the call to Binding.of_caller into the block of it.
+# This should be no problem however, because Ruby has closures.
+# If you don't do this an Exception will be raised. Because of
+# the way that Binding.of_caller is implemented it has to be
+# done this way.
+def Binding.of_caller(&block)
+  old_critical = Thread.critical
+  Thread.critical = true
+  count = 0
+  cc, result, error, extra_data = Continuation.create(nil, nil)
+  error.call if error
+
+  tracer = lambda do |*args|
+    type, context, extra_data = args[0], args[4], args
+    if type == "return"
+      count += 1
+      # First this method and then calling one will return --
+      # the trace event of the second event gets the context
+      # of the method which called the method that called this
+      # method.
+      if count == 2
+        # It would be nice if we could restore the trace_func
+        # that was set before we swapped in our own one, but
+        # this is impossible without overloading set_trace_func
+        # in current Ruby.
+        set_trace_func(nil)
+        cc.call(eval("binding", context), nil, extra_data)
+      end
+    elsif type == "line" then
+      nil
+    elsif type == "c-return" and extra_data[3] == :set_trace_func then
+      nil
+    else
+      set_trace_func(nil)
+      error_msg = "Binding.of_caller used in non-method context or " +
+        "trailing statements of method using it aren't in the block."
+      cc.call(nil, lambda { raise(ArgumentError, error_msg) }, nil)
+    end
+  end
+
+  unless result
+    set_trace_func(tracer)
+    return nil
+  else
+    Thread.critical = old_critical
+    case block.arity
+      when 1 then yield(result)
+      else yield(result, extra_data)        
+    end
+  end
+end