From 4290267959e8c91b8f2a4898d3fa33b15b8b7d57 Mon Sep 17 00:00:00 2001 From: David Heinemeier Hansson Date: Wed, 29 Dec 2004 21:14:58 +0000 Subject: Moved support into Active Support git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@277 5ecf4fe2-1ee6-0310-87b1-e25e094e27de --- activerecord/lib/active_record/acts/list.rb | 101 ++-- activerecord/lib/active_record/associations.rb | 57 +-- .../lib/active_record/support/binding_of_caller.rb | 81 ---- .../lib/active_record/support/breakpoint.rb | 525 --------------------- .../support/class_attribute_accessors.rb | 43 -- .../support/class_inheritable_attributes.rb | 40 -- .../lib/active_record/support/clean_logger.rb | 10 - .../lib/active_record/support/inflector.rb | 79 ---- activerecord/lib/active_record/support/misc.rb | 6 - 9 files changed, 57 insertions(+), 885 deletions(-) delete mode 100644 activerecord/lib/active_record/support/binding_of_caller.rb delete mode 100755 activerecord/lib/active_record/support/breakpoint.rb delete mode 100644 activerecord/lib/active_record/support/class_attribute_accessors.rb delete mode 100644 activerecord/lib/active_record/support/class_inheritable_attributes.rb delete mode 100644 activerecord/lib/active_record/support/clean_logger.rb delete mode 100644 activerecord/lib/active_record/support/inflector.rb delete mode 100644 activerecord/lib/active_record/support/misc.rb (limited to 'activerecord') diff --git a/activerecord/lib/active_record/acts/list.rb b/activerecord/lib/active_record/acts/list.rb index e8f7f64db1..3c0105bbe6 100644 --- a/activerecord/lib/active_record/acts/list.rb +++ b/activerecord/lib/active_record/acts/list.rb @@ -36,19 +36,31 @@ module ActiveRecord configuration[:scope] = "#{configuration[:scope]}_id".intern if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/ + if configuration[:scope].is_a?(Symbol) + scope_condition_method = %( + def scope_condition + if #{configuration[:scope].to_s}.nil? + "#{configuration[:scope].to_s} IS NULL" + else + "#{configuration[:scope].to_s} = \#{#{configuration[:scope].to_s}}" + end + end + ) + else + scope_condition_method = "def scope_condition() \"#{configuration[:scope]}\" end" + end + class_eval <<-EOV include ActiveRecord::Acts::List::InstanceMethods def position_column '#{configuration[:column]}' end - - def scope_condition - "#{configuration[:scope].is_a?(Symbol) ? configuration[:scope].to_s + " = \#{" + configuration[:scope].to_s + "}" : configuration[:scope]}" - end + + #{scope_condition_method} before_destroy :remove_from_list - before_create :add_to_list_bottom + before_create :add_to_list_bottom EOV end end @@ -123,55 +135,54 @@ module ActiveRecord end private - - def add_to_list_top - increment_positions_on_all_items - end + def add_to_list_top + increment_positions_on_all_items + end - def add_to_list_bottom - write_attribute(position_column, bottom_position_in_list.to_i + 1) - end + def add_to_list_bottom + write_attribute(position_column, bottom_position_in_list.to_i + 1) + end - # Overwrite this method to define the scope of the list changes - def scope_condition() "1" end + # Overwrite this method to define the scope of the list changes + def scope_condition() "1" end - def bottom_position_in_list - item = bottom_item - item ? item.send(position_column) : 0 - end + def bottom_position_in_list + item = bottom_item + item ? item.send(position_column) : 0 + end - def bottom_item - self.class.find_first( - "#{scope_condition} ", - "#{position_column} DESC" - ) - end + def bottom_item + self.class.find_first( + "#{scope_condition} ", + "#{position_column} DESC" + ) + end - def assume_bottom_position - update_attribute position_column, bottom_position_in_list.to_i + 1 - end + def assume_bottom_position + update_attribute position_column, bottom_position_in_list.to_i + 1 + end - def assume_top_position - update_attribute position_column, 1 - end + def assume_top_position + update_attribute position_column, 1 + end - def decrement_positions_on_lower_items - self.class.update_all( - "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} > #{send(position_column).to_i}" - ) - end + def decrement_positions_on_lower_items + self.class.update_all( + "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} > #{send(position_column).to_i}" + ) + end - def increment_positions_on_higher_items - self.class.update_all( - "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} < #{send(position_column).to_i}" - ) - end + def increment_positions_on_higher_items + self.class.update_all( + "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} < #{send(position_column).to_i}" + ) + end - def increment_positions_on_all_items - self.class.update_all( - "#{position_column} = (#{position_column} + 1)", "#{scope_condition}" - ) - end + def increment_positions_on_all_items + self.class.update_all( + "#{position_column} = (#{position_column} + 1)", "#{scope_condition}" + ) + end end end end diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb index ccad4120d9..13396c48b1 100755 --- a/activerecord/lib/active_record/associations.rb +++ b/activerecord/lib/active_record/associations.rb @@ -3,30 +3,6 @@ require 'active_record/associations/has_many_association' require 'active_record/associations/has_and_belongs_to_many_association' require 'active_record/deprecated_associations' - -unless Object.respond_to?(:require_association) - Object.send(:define_method, :require_association) { |file_name| ActiveRecord::Base.require_association(file_name) } -end - -class Object - class << self - # Use const_missing to autoload associations so we don't have to - # require_association when using single-table inheritance. - unless respond_to?(:pre_association_const_missing) - alias_method :pre_association_const_missing, :const_missing - - def const_missing(class_id) - begin - require_association(Inflector.underscore(Inflector.demodulize(class_id.to_s))) - return Object.const_get(class_id) if Object.const_defined?(class_id) && Object.const_get(class_id).ancestors.include?(ActiveRecord::Base) - rescue LoadError - pre_association_const_missing(class_id) - end - end - end - end -end - module ActiveRecord module Associations # :nodoc: def self.append_features(base) @@ -478,31 +454,6 @@ module ActiveRecord deprecated_has_collection_method(association_name) end - # Loads the file_name if reload_associations is true or requires if it's false. - def require_association(file_name) - if !associations_loaded.include?(file_name) - associations_loaded << file_name - reload_associations ? silence_warnings { load("#{file_name}.rb") } : require(file_name) - end - end - - # Resets the list of dependencies loaded (typically to be called by the end of a request), so when require_association is - # called for that dependency it'll be loaded anew. - def reset_associations_loaded - self.associations_loaded = [] - end - - # Reload all the associations that have already been loaded once. - def reload_associations_loaded - associations_loaded.each do |file_name| - begin - silence_warnings { load("#{file_name}.rb") } - rescue LoadError - # The association didn't reside in its own file, so we assume it was required by other means - end - end - end - private # Raises an exception if an invalid option has been specified to prevent misspellings from slipping through def validate_options(valid_option_keys, supplied_option_keys) @@ -619,13 +570,7 @@ module ActiveRecord end def require_association_class(class_name) - return unless class_name - - begin - require_association(Inflector.underscore(class_name)) - rescue LoadError - # Failed to load the associated class -- let's hope the developer is doing the requiring himself. - end + require_association(Inflector.underscore(class_name)) if class_name end end end diff --git a/activerecord/lib/active_record/support/binding_of_caller.rb b/activerecord/lib/active_record/support/binding_of_caller.rb deleted file mode 100644 index 64b945158c..0000000000 --- a/activerecord/lib/active_record/support/binding_of_caller.rb +++ /dev/null @@ -1,81 +0,0 @@ -begin - require 'simplecc' -rescue LoadError - def Continuation.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 - -# 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 diff --git a/activerecord/lib/active_record/support/breakpoint.rb b/activerecord/lib/active_record/support/breakpoint.rb deleted file mode 100755 index d9925be600..0000000000 --- a/activerecord/lib/active_record/support/breakpoint.rb +++ /dev/null @@ -1,525 +0,0 @@ -# The Breakpoint library provides the convenience of -# being able to inspect and modify state, diagnose -# bugs all via IRB by simply setting breakpoints in -# your applications by the call of a method. -# -# This library was written and is supported by me, -# Florian Gross. I can be reached at flgr@ccan.de -# and enjoy getting feedback about my libraries. -# -# The whole library (including breakpoint_client.rb -# and binding_of_caller.rb) is licensed under the -# same license that Ruby uses. (Which is currently -# either the GNU General Public License or a custom -# one that allows for commercial usage.) If you for -# some good reason need to use this under another -# license please contact me. - -require 'irb' -# require 'binding_of_caller' <- Needs this -require 'drb' -require 'drb/acl' - -module Breakpoint - extend self - - # This will pop up an interactive ruby session at a - # pre-defined break point in a Ruby application. In - # this session you can examine the environment of - # the break point. - # - # You can get a list of variables in the context using - # local_variables via +local_variables+. You can then - # examine their values by typing their names. - # - # You can have a look at the call stack via +caller+. - # - # The source code around the location where the breakpoint - # was executed can be examined via +source_lines+. Its - # argument specifies how much lines of context to display. - # The default amount of context is 5 lines. Note that - # the call to +source_lines+ can raise an exception when - # it isn't able to read in the source code. - # - # breakpoints can also return a value. They will execute - # a supplied block for getting a default return value. - # A custom value can be returned from the session by doing - # +throw(:debug_return, value)+. - # - # You can also give names to break points which will be - # used in the message that is displayed upon execution - # of them. - # - # Here's a sample of how breakpoints should be placed: - # - # class Person - # def initialize(name, age) - # @name, @age = name, age - # breakpoint("Person#initialize") - # end - # - # attr_reader :age - # def name - # breakpoint("Person#name") { @name } - # end - # end - # - # person = Person.new("Random Person", 23) - # puts "Name: #{person.name}" - # - # And here is a sample debug session: - # - # Executing break point "Person#initialize" at file.rb:4 in `initialize' - # irb(#):001:0> local_variables - # => ["name", "age", "_", "__"] - # irb(#):002:0> [name, age] - # => ["Random Person", 23] - # irb(#):003:0> [@name, @age] - # => ["Random Person", 23] - # irb(#):004:0> self - # => # - # irb(#):005:0> @age += 1; self - # => # - # irb(#):006:0> exit - # Executing break point "Person#name" at file.rb:9 in `name' - # irb(#):001:0> throw(:debug_return, "Overriden name") - # Name: Overriden name - # - # Breakpoint sessions will automatically have a few - # convenience methods available. See Breakpoint::CommandBundle - # for a list of them. - # - # Breakpoints can also be used remotely over sockets. - # This is implemented by running part of the IRB session - # in the application and part of it in a special client. - # You have to call Breakpoint.activate_drb to enable - # support for remote breakpoints and then run - # breakpoint_client.rb which is distributed with this - # library. See the documentation of Breakpoint.activate_drb - # for details. - def breakpoint(id = nil, context = nil, &block) - callstack = caller - callstack.slice!(0, 3) if callstack.first["breakpoint"] - file, line, method = *callstack.first.match(/^(.+?):(\d+)(?::in `(.*?)')?/).captures - - message = "Executing break point " + (id ? "#{id.inspect} " : "") + - "at #{file}:#{line}" + (method ? " in `#{method}'" : "") - - if context then - return handle_breakpoint(context, message, file, line, &block) - end - - Binding.of_caller do |binding_context| - handle_breakpoint(binding_context, message, file, line, &block) - end - end - - module CommandBundle #:nodoc: - # Proxy to a Breakpoint client. Lets you directly execute code - # in the context of the client. - class Client#:nodoc: - def initialize(eval_handler) # :nodoc: - @eval_handler = eval_handler - end - - instance_methods.each do |method| - next if method[/^__.+__$/] - undef_method method - end - - # Executes the specified code at the client. - def eval(code) - @eval_handler.call(code) - end - - # Will execute the specified statement at the client. - def method_missing(method, *args) - if args.empty? - result = eval("#{method}") - else - result = eval("#{method}(*Marshal.load(#{Marshal.dump(args).inspect}))") - end - - unless [true, false, nil].include?(result) - result.extend(DRbUndumped) if result - end - - return result - end - end - - # Returns the source code surrounding the location where the - # breakpoint was issued. - def source_lines(context = 5, return_line_numbers = false) - lines = File.readlines(@__bp_file).map { |line| line.chomp } - - break_line = @__bp_line - start_line = [break_line - context, 1].max - end_line = break_line + context - - result = lines[(start_line - 1) .. (end_line - 1)] - - if return_line_numbers then - return [start_line, break_line, result] - else - return result - end - end - - # Lets an object that will forward method calls to the breakpoint - # client. This is useful for outputting longer things at the client - # and so on. You can for example do these things: - # - # client.puts "Hello" # outputs "Hello" at client console - # # outputs "Hello" into the file temp.txt at the client - # client.File.open("temp.txt", "w") { |f| f.puts "Hello" } - def client() - if Breakpoint.use_drb? then - Client.new(Breakpoint.drb_service.eval_handler) - else - Client.new(lambda { |code| eval(code, TOPLEVEL_BINDING) }) - end - end - end - - def handle_breakpoint(context, message, file = "", line = "", &block) # :nodoc: - catch(:debug_return) do |value| - eval(%{ - @__bp_file = #{file.inspect} - @__bp_line = #{line} - extend Breakpoint::CommandBundle - extend DRbUndumped if self - }, context) rescue nil - - if not use_drb? then - puts message - IRB.start(nil, IRB::WorkSpace.new(context)) - else - @drb_service.add_breakpoint(context, message) - end - - block.call if block - end - end - - # These exceptions will be raised on failed asserts - # if Breakpoint.asserts_cause_exceptions is set to - # true. - class FailedAssertError < RuntimeError#:nodoc: - end - - # This asserts that the block evaluates to true. - # If it doesn't evaluate to true a breakpoint will - # automatically be created at that execution point. - # - # You can disable assert checking in production - # code by setting Breakpoint.optimize_asserts to - # true. (It will still be enabled when Ruby is run - # via the -d argument.) - # - # Example: - # person_name = "Foobar" - # assert { not person_name.nil? } - # - # Note: If you want to use this method from an - # unit test, you will have to call it by its full - # name, Breakpoint.assert. - def assert(context = nil, &condition) - return if Breakpoint.optimize_asserts and not $DEBUG - return if yield - - callstack = caller - callstack.slice!(0, 3) if callstack.first["assert"] - file, line, method = *callstack.first.match(/^(.+?):(\d+)(?::in `(.*?)')?/).captures - - message = "Assert failed at #{file}:#{line}#{" in `#{method}'" if method}." - - if Breakpoint.asserts_cause_exceptions and not $DEBUG then - raise(Breakpoint::FailedAssertError, message) - end - - message += " Executing implicit breakpoint." - - if context then - return handle_breakpoint(context, message, file, line) - end - - Binding.of_caller do |context| - handle_breakpoint(context, message, file, line) - end - end - - # Whether asserts should be ignored if not in debug mode. - # Debug mode can be enabled by running ruby with the -d - # switch or by setting $DEBUG to true. - attr_accessor :optimize_asserts - self.optimize_asserts = false - - # Whether an Exception should be raised on failed asserts - # in non-$DEBUG code or not. By default this is disabled. - attr_accessor :asserts_cause_exceptions - self.asserts_cause_exceptions = false - @use_drb = false - - attr_reader :drb_service # :nodoc: - - class DRbService # :nodoc: - include DRbUndumped - - def initialize - @handler = @eval_handler = @collision_handler = nil - - IRB.instance_eval { @CONF[:RC] = true } - IRB.run_config - end - - def collision - sleep(0.5) until @collision_handler - - @collision_handler.call - end - - def ping; end - - def add_breakpoint(context, message) - workspace = IRB::WorkSpace.new(context) - workspace.extend(DRbUndumped) - - sleep(0.5) until @handler - - @handler.call(workspace, message) - end - - def register_handler(&block) - @handler = block - end - - def unregister_handler - @handler = nil - end - - attr_reader :eval_handler - - def register_eval_handler(&block) - @eval_handler = block - end - - def unregister_eval_handler - @eval_handler = lambda { } - end - - def register_collision_handler(&block) - @collision_handler = block - end - - def unregister_collision_handler - @collision_handler = lambda { } - end - end - - # Will run Breakpoint in DRb mode. This will spawn a server - # that can be attached to via the breakpoint-client command - # whenever a breakpoint is executed. This is useful when you - # are debugging CGI applications or other applications where - # you can't access debug sessions via the standard input and - # output of your application. - # - # You can specify an URI where the DRb server will run at. - # This way you can specify the port the server runs on. The - # default URI is druby://localhost:42531. - # - # Please note that breakpoints will be skipped silently in - # case the DRb server can not spawned. (This can happen if - # the port is already used by another instance of your - # application on CGI or another application.) - # - # Also note that by default this will only allow access - # from localhost. You can however specify a list of - # allowed hosts or nil (to allow access from everywhere). - # But that will still not protect you from somebody - # reading the data as it goes through the net. - # - # A good approach for getting security and remote access - # is setting up an SSH tunnel between the DRb service - # and the client. This is usually done like this: - # - # $ ssh -L20000:127.0.0.1:20000 -R10000:127.0.0.1:10000 example.com - # (This will connect port 20000 at the client side to port - # 20000 at the server side, and port 10000 at the server - # side to port 10000 at the client side.) - # - # After that do this on the server side: (the code being debugged) - # Breakpoint.activate_drb("druby://127.0.0.1:20000", "localhost") - # - # And at the client side: - # ruby breakpoint_client.rb -c druby://127.0.0.1:10000 -s druby://127.0.0.1:20000 - # - # Running through such a SSH proxy will also let you use - # breakpoint.rb in case you are behind a firewall. - # - # Detailed information about running DRb through firewalls is - # available at http://www.rubygarden.org/ruby?DrbTutorial - def activate_drb(uri = nil, allowed_hosts = ['localhost', '127.0.0.1', '::1'], ignore_collisions = false) #:nodoc: - - return false if @use_drb - - uri ||= 'druby://localhost:42531' - - if allowed_hosts then - acl = ["deny", "all"] - - Array(allowed_hosts).each do |host| - acl += ["allow", host] - end - - DRb.install_acl(ACL.new(acl)) - end - - @use_drb = true - @drb_service = DRbService.new - did_collision = false - begin - @service = DRb.start_service(uri, @drb_service) - rescue Errno::EADDRINUSE - if ignore_collisions then - nil - else - # The port is already occupied by another - # Breakpoint service. We will try to tell - # the old service that we want its port. - # It will then forward that request to the - # user and retry. - unless did_collision then - DRbObject.new(nil, uri).collision - did_collision = true - end - sleep(10) - retry - end - end - - return true - end - - # Deactivates a running Breakpoint service. - def deactivate_drb #:nodoc: - @service.stop_service unless @service.nil? - @service = nil - @use_drb = false - @drb_service = nil - end - - # Returns true when Breakpoints are used over DRb. - # Breakpoint.activate_drb causes this to be true. - def use_drb? #:nodoc: - @use_drb == true - end -end - -module IRB # :nodoc: - class << self; remove_method :start; end - def self.start(ap_path = nil, main_context = nil, workspace = nil) - $0 = File::basename(ap_path, ".rb") if ap_path - - # suppress some warnings about redefined constants - old_verbose, $VERBOSE = $VERBOSE, nil - IRB.setup(ap_path) - $VERBOSE = old_verbose - - if @CONF[:SCRIPT] then - irb = Irb.new(main_context, @CONF[:SCRIPT]) - else - irb = Irb.new(main_context) - end - - if workspace then - irb.context.workspace = workspace - end - - @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC] - @CONF[:MAIN_CONTEXT] = irb.context - - old_sigint = trap("SIGINT") do - irb.signal_handle - end - - catch(:IRB_EXIT) do - irb.eval_input - end - ensure - trap("SIGINT", old_sigint) - end - - class << self - alias :old_CurrentContext :CurrentContext - remove_method :CurrentContext - end - def IRB.CurrentContext - if old_CurrentContext.nil? and Breakpoint.use_drb? then - result = Object.new - def result.last_value; end - return result - else - old_CurrentContext - end - end - - class Context#:nodoc: - alias :old_evaluate :evaluate - def evaluate(line, line_no) - if line.chomp == "exit" then - exit - else - old_evaluate(line, line_no) - end - end - end - - class WorkSpace#:nodoc: - alias :old_evaluate :evaluate - - def evaluate(*args) - if Breakpoint.use_drb? then - result = old_evaluate(*args) - if args[0] != :no_proxy and - not [true, false, nil].include?(result) - then - result.extend(DRbUndumped) rescue nil - end - return result - else - old_evaluate(*args) - end - end - end - - module InputCompletor#:nodoc: - def self.eval(code, context, *more) - # Big hack, this assumes that InputCompletor - # will only call eval() when it wants code - # to be executed in the IRB context. - IRB.conf[:MAIN_CONTEXT].workspace.evaluate(:no_proxy, code, *more) - end - end -end - -module DRb # :nodoc: - class DRbObject#:nodoc: - undef :inspect - undef :clone - end -end - -# See Breakpoint.breakpoint -def breakpoint(id = nil, &block) - Binding.of_caller do |context| - Breakpoint.breakpoint(id, context, &block) - end -end - -# See Breakpoint.assert -def assert(&block) - Binding.of_caller do |context| - Breakpoint.assert(context, &block) - end -end \ No newline at end of file diff --git a/activerecord/lib/active_record/support/class_attribute_accessors.rb b/activerecord/lib/active_record/support/class_attribute_accessors.rb deleted file mode 100644 index 0e269165a6..0000000000 --- a/activerecord/lib/active_record/support/class_attribute_accessors.rb +++ /dev/null @@ -1,43 +0,0 @@ -# attr_* style accessors for class-variables that can accessed both on an instance and class level. -class Class #:nodoc: - def cattr_reader(*syms) - syms.each do |sym| - class_eval <<-EOS - if ! defined? @@#{sym.id2name} - @@#{sym.id2name} = nil - end - - def self.#{sym.id2name} - @@#{sym} - end - - def #{sym.id2name} - self.class.#{sym.id2name} - end - EOS - end - end - - def cattr_writer(*syms) - syms.each do |sym| - class_eval <<-EOS - if ! defined? @@#{sym.id2name} - @@#{sym.id2name} = nil - end - - def self.#{sym.id2name}=(obj) - @@#{sym.id2name} = obj - end - - def #{sym.id2name}=(obj) - self.class.#{sym.id2name}=(obj) - end - EOS - end - end - - def cattr_accessor(*syms) - cattr_reader(*syms) - cattr_writer(*syms) - end -end \ No newline at end of file diff --git a/activerecord/lib/active_record/support/class_inheritable_attributes.rb b/activerecord/lib/active_record/support/class_inheritable_attributes.rb deleted file mode 100644 index 201932cf2d..0000000000 --- a/activerecord/lib/active_record/support/class_inheritable_attributes.rb +++ /dev/null @@ -1,40 +0,0 @@ -# Allows attributes to be shared within an inheritance hierarchy, but where each descentent gets a copy of -# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements -# to, for example, an array without those additions being shared with either their parent, siblings, or -# children, which is unlike the regular class-level attributes that are shared across the entire hierarchy. -module ClassInheritableAttributes # :nodoc: - def self.append_features(base) - super - base.extend(ClassMethods) - end - - module ClassMethods # :nodoc: - @@classes ||= {} - - def inheritable_attributes - @@classes[self] ||= {} - end - - def write_inheritable_attribute(key, value) - inheritable_attributes[key] = value - end - - def write_inheritable_array(key, elements) - write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil? - write_inheritable_attribute(key, read_inheritable_attribute(key) + elements) - end - - def read_inheritable_attribute(key) - inheritable_attributes[key] - end - - def reset_inheritable_attributes - inheritable_attributes.clear - end - - private - def inherited(child) - @@classes[child] = inheritable_attributes.dup - end - end -end diff --git a/activerecord/lib/active_record/support/clean_logger.rb b/activerecord/lib/active_record/support/clean_logger.rb deleted file mode 100644 index 1a36562892..0000000000 --- a/activerecord/lib/active_record/support/clean_logger.rb +++ /dev/null @@ -1,10 +0,0 @@ -require 'logger' - -class Logger #:nodoc: - private - remove_const "Format" - Format = "%s\n" - def format_message(severity, timestamp, msg, progname) - Format % [msg] - end -end \ No newline at end of file diff --git a/activerecord/lib/active_record/support/inflector.rb b/activerecord/lib/active_record/support/inflector.rb deleted file mode 100644 index bc5724e742..0000000000 --- a/activerecord/lib/active_record/support/inflector.rb +++ /dev/null @@ -1,79 +0,0 @@ -# The Inflector transforms words from singular to plural, class names to table names, modulized class names to ones without, -# and class names to foreign keys. -module Inflector - extend self - - def pluralize(word) - result = word.dup - plural_rules.each do |(rule, replacement)| - break if result.gsub!(rule, replacement) - end - return result - end - - def singularize(word) - result = word.dup - singular_rules.each do |(rule, replacement)| - break if result.gsub!(rule, replacement) - end - return result - end - - def camelize(lower_case_and_underscored_word) - lower_case_and_underscored_word.gsub(/(^|_)(.)/){$2.upcase} - end - - def underscore(camel_cased_word) - camel_cased_word.gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase - end - - def demodulize(class_name_in_module) - class_name_in_module.gsub(/^.*::/, '') - end - - def tableize(class_name) - pluralize(underscore(class_name)) - end - - def classify(table_name) - camelize(singularize(table_name)) - end - - def foreign_key(class_name, separate_class_name_and_id_with_underscore = true) - Inflector.underscore(Inflector.demodulize(class_name)) + - (separate_class_name_and_id_with_underscore ? "_id" : "id") - end - - private - def plural_rules #:doc: - [ - [/(x|ch|ss)$/, '\1es'], # search, switch, fix, box, process, address - [/([^aeiouy]|qu)y$/, '\1ies'], # query, ability, agency - [/(?:([^f])fe|([lr])f)$/, '\1\2ves'], # half, safe, wife - [/sis$/, 'ses'], # basis, diagnosis - [/([ti])um$/, '\1a'], # datum, medium - [/person$/, 'people'], # person, salesperson - [/man$/, 'men'], # man, woman, spokesman - [/child$/, 'children'], # child - [/s$/, 's'], # no change (compatibility) - [/$/, 's'] - ] - end - - def singular_rules #:doc: - [ - [/(x|ch|ss)es$/, '\1'], - [/movies$/, 'movie'], - [/([^aeiouy]|qu)ies$/, '\1y'], - [/([lr])ves$/, '\1f'], - [/([^f])ves$/, '\1fe'], - [/(analy|ba|diagno|parenthe|progno|synop|the)ses$/, '\1sis'], - [/([ti])a$/, '\1um'], - [/people$/, 'person'], - [/men$/, 'man'], - [/status$/, 'status'], - [/children$/, 'child'], - [/s$/, ''] - ] - end -end \ No newline at end of file diff --git a/activerecord/lib/active_record/support/misc.rb b/activerecord/lib/active_record/support/misc.rb deleted file mode 100644 index db842f6061..0000000000 --- a/activerecord/lib/active_record/support/misc.rb +++ /dev/null @@ -1,6 +0,0 @@ -def silence_warnings - old_verbose, $VERBOSE = $VERBOSE, nil - result = yield - $VERBOSE = old_verbose - return result -end -- cgit v1.2.3