Class Object < BasicObject

# File activesupport/lib/active_support/core_ext/object/acts_like.rb, line 7
def acts_like?(duck)
  respond_to? :"acts_like_#{duck}?"
end

# File activesupport/lib/active_support/core_ext/object/blank.rb, line 14
def blank?
  respond_to?(:empty?) ? empty? : !self
end

# File railties/guides/rails_guides.rb, line 5
def bundler?
  # Note that rake sets the cwd to the one that contains the Rakefile
  # being executed.
  File.exists?('Gemfile')
end

# File railties/lib/rails/test_help.rb, line 45
def create_fixtures(*table_names, &block)
  Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, {}, &block)
end

# File activerecord/test/schema/schema.rb, line 14
def create_table(*args, &block)
  ActiveRecord::Base.connection.create_table(*args, &block)
  ActiveRecord::Base.connection.execute "SET GENERATOR #{args.first}_seq TO 10000"
end

# File activerecord/test/cases/helper.rb, line 29
def current_adapter?(*types)
  types.any? do |type|
    ActiveRecord::ConnectionAdapters.const_defined?(type) &&
      ActiveRecord::Base.connection.is_a?(ActiveRecord::ConnectionAdapters.const_get(type))
  end
end

# File activesupport/lib/active_support/core_ext/object/duplicable.rb, line 24
def duplicable?
  true
end

# File activerecord/test/schema/schema.rb, line 2
def except(adapter_names_to_exclude)
  unless [adapter_names_to_exclude].flatten.include?(adapter_name)
    yield
  end
end

# File activesupport/lib/active_support/core_ext/string/output_safety.rb, line 76
def html_safe?
  false
end

# File activesupport/lib/active_support/core_ext/object/inclusion.rb, line 13
def in?(*args)
  if args.length > 1
    args.include? self
  else
    another_object = args.first
    if another_object.respond_to? :include?
      another_object.include? self
    else
      raise ArgumentError.new("The single parameter passed to #in? must respond to #include?")
    end
  end
end

# File activerecord/test/cases/helper.rb, line 36
def in_memory_db?
  current_adapter?(:SQLiteAdapter) &&
  ActiveRecord::Base.connection_pool.spec.config[:database] == ":memory:"
end

# File activesupport/lib/active_support/core_ext/object/instance_variables.rb, line 27
def instance_variable_names
  instance_variables.map { |var| var.to_s }
end

# File activerecord/test/cases/helper.rb, line 117
def load_schema
  # silence verbose schema loading
  original_stdout = $stdout
  $stdout = StringIO.new

  adapter_name = ActiveRecord::Base.connection.adapter_name.downcase
  adapter_specific_schema_file = SCHEMA_ROOT + "/#{adapter_name}_specific_schema.rb"

  load SCHEMA_ROOT + "/schema.rb"

  if File.exists?(adapter_specific_schema_file)
    load adapter_specific_schema_file
  end
ensure
  $stdout = original_stdout
end

# File railties/lib/rails/commands/benchmarker.rb, line 8
def options
  options = {}
  defaults = ActiveSupport::Testing::Performance::DEFAULTS

  OptionParser.new do |opt|
    opt.banner = "Usage: rails benchmarker 'Ruby.code' 'Ruby.more_code' ... [OPTS]"
    opt.on('-r', '--runs N', Numeric, 'Number of runs.', "Default: #{defaults[:runs]}") { |r| options[:runs] = r }
    opt.on('-o', '--output PATH', String, 'Directory to use when writing the results.', "Default: #{defaults[:output]}") { |o| options[:output] = o }
    opt.on('-m', '--metrics a,b,c', Array, 'Metrics to use.', "Default: #{defaults[:metrics].join(",")}") { |m| options[:metrics] = m.map(&:to_sym) }
    opt.parse!(ARGV)
  end

  options
end

# File activerecord/test/cases/ar_schema_test.rb, line 52
def perform_schema_define!
  ActiveRecord::Schema.define(:version => 7) do
    create_table :fruits do |t|
      t.column :color, :string
      t.column :fruit_size, :string  # NOTE: "size" is reserved in Oracle
      t.column :texture, :string
      t.column :flavor, :string
    end
  end
end

# File activesupport/lib/active_support/core_ext/object/blank.rb, line 37
def presence
  self if present?
end

# File activesupport/lib/active_support/core_ext/object/blank.rb, line 19
def present?
  !blank?
end

# File actionmailer/test/abstract_unit.rb, line 77
def restore_delivery_method
  ActionMailer::Base.delivery_method = @old_delivery_method
end

# File actionpack/examples/performance.rb, line 156
def run_all!(times, verbose)
  Runner.run(:overhead, times, verbose)
  Runner.run(:index,       times, verbose)
  Runner.run(:template_1,  times, verbose)
  Runner.run(:partial,     times, verbose)
  Runner.run(:partial_10,  times, verbose)
  Runner.run(:coll_10,     times, verbose)
  Runner.run(:partial_100, times, verbose)
  Runner.run(:coll_100,    times, verbose)
  Runner.run(:uniq_100,    times, verbose)
  Runner.run(:diff_100,    times, verbose)
end

# File actionmailer/test/abstract_unit.rb, line 72
def set_delivery_method(method)
  @old_delivery_method = ActionMailer::Base.delivery_method
  ActionMailer::Base.delivery_method = method
end

# File activeresource/test/abstract_unit.rb, line 16
def setup_response
  matz_hash = { 'person' => { :id => 1, :name => 'Matz' } }

  @default_request_headers = { 'Content-Type' => 'application/json' }
  @matz  = matz_hash.to_json
  @matz_xml  = matz_hash.to_xml
  @david = { :person => { :id => 2, :name => 'David' } }.to_json
  @greg  = { :person => { :id => 3, :name => 'Greg' } }.to_json
  @addy  = { :address => { :id => 1, :street => '12345 Street', :country => 'Australia' } }.to_json
  @rick  = { :person => { :name => "Rick", :age => 25 } }.to_json
  @joe    = { :person => { :id => 6, :name => 'Joe', :likes_hats => true }}.to_json
  @people = { :people => [ { :person => { :id => 1, :name => 'Matz' } }, { :person => { :id => 2, :name => 'David' } }] }.to_json
  @people_david = { :people => [ { :person => { :id => 2, :name => 'David' } }] }.to_json
  @addresses = { :addresses => [{ :address => { :id => 1, :street => '12345 Street', :country => 'Australia' } }] }.to_json

  # - deep nested resource -
  # - Luis (Customer)
  #   - JK (Customer::Friend)
  #     - Mateo (Customer::Friend::Brother)
  #       - Edith (Customer::Friend::Brother::Child)
  #       - Martha (Customer::Friend::Brother::Child)
  #     - Felipe (Customer::Friend::Brother)
  #       - Bryan (Customer::Friend::Brother::Child)
  #       - Luke (Customer::Friend::Brother::Child)
  #   - Eduardo (Customer::Friend)
  #     - Sebas (Customer::Friend::Brother)
  #       - Andres (Customer::Friend::Brother::Child)
  #       - Jorge (Customer::Friend::Brother::Child)
  #     - Elsa (Customer::Friend::Brother)
  #       - Natacha (Customer::Friend::Brother::Child)
  #     - Milena (Customer::Friend::Brother)
  #
  @luis = {
    :customer => {
      :id => 1,
      :name => 'Luis',
      :friends => [{
        :name => 'JK',
        :brothers => [
          {
            :name => 'Mateo',
            :children => [{ :name => 'Edith' },{ :name => 'Martha' }]
          }, {
            :name => 'Felipe',
            :children => [{ :name => 'Bryan' },{ :name => 'Luke' }]
          }
        ]
      }, {
        :name => 'Eduardo',
        :brothers => [
          {
            :name => 'Sebas',
            :children => [{ :name => 'Andres' },{ :name => 'Jorge' }]
          }, {
            :name => 'Elsa',
            :children => [{ :name => 'Natacha' }]
          }, {
            :name => 'Milena',
            :children => []
          }
        ]
      }]
    }
  }.to_json

  @startup_sound = {
    :sound => {
      :name => "Mac Startup Sound", :author => { :name => "Jim Reekes" }
    }
  }.to_json

  ActiveResource::HttpMock.respond_to do |mock|
    mock.get    "/people/1.json",               {}, @matz
    mock.get    "/people/1.xml",                {}, @matz_xml
    mock.get    "/people/2.xml",                {}, @david
    mock.get    "/people/Greg.json",            {}, @greg
    mock.get    "/people/6.json",               {}, @joe
    mock.get    "/people/4.json",               { 'key' => 'value' }, nil, 404
    mock.put    "/people/1.json",               {}, nil, 204
    mock.delete "/people/1.json",               {}, nil, 200
    mock.delete "/people/2.xml",                {}, nil, 400
    mock.get    "/people/99.json",              {}, nil, 404
    mock.post   "/people.json",                 {}, @rick, 201, 'Location' => '/people/5.xml'
    mock.get    "/people.json",                 {}, @people
    mock.get    "/people/1/addresses.json",     {}, @addresses
    mock.get    "/people/1/addresses/1.json",   {}, @addy
    mock.get    "/people/1/addresses/2.xml",    {}, nil, 404
    mock.get    "/people/2/addresses.json",     {}, nil, 404
    mock.get    "/people/2/addresses/1.xml",    {}, nil, 404
    mock.get    "/people/Greg/addresses/1.json", {}, @addy
    mock.put    "/people/1/addresses/1.json",   {}, nil, 204
    mock.delete "/people/1/addresses/1.json",   {}, nil, 200
    mock.post   "/people/1/addresses.json",     {}, nil, 201, 'Location' => '/people/1/addresses/5'
    mock.get    "/people/1/addresses/99.json",  {}, nil, 404
    mock.get    "/people//addresses.xml",       {}, nil, 404
    mock.get    "/people//addresses/1.xml",     {}, nil, 404
    mock.put    "/people//addresses/1.xml",     {}, nil, 404
    mock.delete "/people//addresses/1.xml",     {}, nil, 404
    mock.post   "/people//addresses.xml",       {}, nil, 404
    mock.head   "/people/1.json",               {}, nil, 200
    mock.head   "/people/Greg.json",            {}, nil, 200
    mock.head   "/people/99.json",              {}, nil, 404
    mock.head   "/people/1/addresses/1.json",   {}, nil, 200
    mock.head   "/people/1/addresses/2.json",   {}, nil, 404
    mock.head   "/people/2/addresses/1.json",    {}, nil, 404
    mock.head   "/people/Greg/addresses/1.json", {}, nil, 200
    # customer
    mock.get    "/customers/1.json",             {}, @luis
    # sound
    mock.get    "/sounds/1.json",                {}, @startup_sound
  end

  Person.user = nil
  Person.password = nil
end

# File activerecord/test/cases/helper.rb, line 41
def supports_savepoints?
  ActiveRecord::Base.connection.supports_savepoints?
end

# File activerecord/test/cases/inheritance_test.rb, line 245
def switch_to_alt_inheritance_column
  # we don't want misleading test results, so get rid of the values in the type column
  Company.find(:all, :order => 'id').each do |c|
    c['type'] = nil
    c.save
  end
  [ Company, Firm, Client].each { |klass| klass.reset_column_information }
  Company.inheritance_column = 'ruby_type'
end

# File activerecord/test/cases/inheritance_test.rb, line 254
def switch_to_default_inheritance_column
  [ Company, Firm, Client].each { |klass| klass.reset_column_information }
  Company.inheritance_column = 'type'
end

# File activerecord/test/cases/inheritance_test.rb, line 75
def test_a_bad_type_column
  #SQLServer need to turn Identity Insert On before manually inserting into the Identity column
  if current_adapter?(:SybaseAdapter)
    Company.connection.execute "SET IDENTITY_INSERT companies ON"
  end
  Company.connection.insert "INSERT INTO companies (id, #{QUOTED_TYPE}, name) VALUES(100, 'bad_class!', 'Not happening')"

  #We then need to turn it back Off before continuing.
  if current_adapter?(:SybaseAdapter)
    Company.connection.execute "SET IDENTITY_INSERT companies OFF"
  end
  assert_raise(ActiveRecord::SubclassNotFound) { Company.find(100) }
end

# File activerecord/test/cases/inheritance_test.rb, line 102
def test_alt_becomes_works_with_sti
  vegetable = Vegetable.find(1)
  assert_kind_of Vegetable, vegetable
  cabbage = vegetable.becomes(Cabbage)
  assert_kind_of Cabbage, cabbage
end

# File activerecord/test/cases/inheritance_test.rb, line 206
def test_alt_complex_inheritance
  switch_to_alt_inheritance_column
  test_complex_inheritance
  switch_to_default_inheritance_column
end

# File activerecord/test/cases/inheritance_test.rb, line 178
def test_alt_destroy_all_within_inheritance
  switch_to_alt_inheritance_column
  test_destroy_all_within_inheritance
  switch_to_default_inheritance_column
end

# File activerecord/test/cases/inheritance_test.rb, line 224
def test_alt_eager_loading
  switch_to_alt_inheritance_column
  test_eager_load_belongs_to_something_inherited
  switch_to_default_inheritance_column
end

# File activerecord/test/cases/inheritance_test.rb, line 190
def test_alt_find_first_within_inheritance
  switch_to_alt_inheritance_column
  test_find_first_within_inheritance
  switch_to_default_inheritance_column
end

# File activerecord/test/cases/inheritance_test.rb, line 153
def test_alt_finding_incorrect_type_data
  switch_to_alt_inheritance_column
  test_finding_incorrect_type_data
  switch_to_default_inheritance_column
end

# File activerecord/test/cases/inheritance_test.rb, line 142
def test_alt_inheritance_condition
  switch_to_alt_inheritance_column
  test_inheritance_condition
  switch_to_default_inheritance_column
end

# File activerecord/test/cases/inheritance_test.rb, line 96
def test_alt_inheritance_find
  switch_to_alt_inheritance_column
  test_inheritance_find
  switch_to_default_inheritance_column
end

# File activerecord/test/cases/inheritance_test.rb, line 115
def test_alt_inheritance_find_all
  switch_to_alt_inheritance_column
  test_inheritance_find_all
  switch_to_default_inheritance_column
end

# File activerecord/test/cases/inheritance_test.rb, line 130
def test_alt_inheritance_save
  switch_to_alt_inheritance_column
  test_inheritance_save
  switch_to_default_inheritance_column
end

# File activerecord/test/cases/inheritance_test.rb, line 166
def test_alt_update_all_within_inheritance
  switch_to_alt_inheritance_column
  test_update_all_within_inheritance
  switch_to_default_inheritance_column
end

# File activerecord/test/cases/inheritance_test.rb, line 32
def test_class_without_store_full_sti_class_returns_demodulized_name
  old = ActiveRecord::Base.store_full_sti_class
  ActiveRecord::Base.store_full_sti_class = false
  assert_equal 'Company', Namespaced::Company.sti_name
ensure
  ActiveRecord::Base.store_full_sti_class = old
end

# File activerecord/test/cases/inheritance_test.rb, line 68
def test_company_descends_from_active_record
  assert_raise(NoMethodError) { ActiveRecord::Base.descends_from_active_record? }
  assert AbstractCompany.descends_from_active_record?, 'AbstractCompany should descend from ActiveRecord::Base'
  assert Company.descends_from_active_record?, 'Company should descend from ActiveRecord::Base'
  assert !Class.new(Company).descends_from_active_record?, 'Company subclass should not descend from ActiveRecord::Base'
end

# File activerecord/test/cases/inheritance_test.rb, line 196
def test_complex_inheritance
  very_special_client = VerySpecialClient.create("name" => "veryspecial")
  assert_equal very_special_client, VerySpecialClient.where("name = 'veryspecial'").first
  assert_equal very_special_client, SpecialClient.find(:first, :conditions => "name = 'veryspecial'")
  assert_equal very_special_client, Company.find(:first, :conditions => "name = 'veryspecial'")
  assert_equal very_special_client, Client.find(:first, :conditions => "name = 'veryspecial'")
  assert_equal 1, Client.find(:all, :conditions => "name = 'Summit'").size
  assert_equal very_special_client, Client.find(very_special_client.id)
end

# File activerecord/test/cases/inheritance_test.rb, line 172
def test_destroy_all_within_inheritance
  Client.destroy_all
  assert_equal 0, Client.count
  assert_equal 2, Firm.count
end

# File activerecord/test/cases/inheritance_test.rb, line 58
def test_different_namespace_subclass_should_load_correctly_with_store_full_sti_class_option
  old = ActiveRecord::Base.store_full_sti_class
  ActiveRecord::Base.store_full_sti_class = true
  item = Namespaced::Company.create :name => "Wolverine 2"
  assert_not_nil Company.find(item.id)
  assert_not_nil Namespaced::Company.find(item.id)
ensure
  ActiveRecord::Base.store_full_sti_class = old
end

# File activerecord/test/cases/inheritance_test.rb, line 217
def test_eager_load_belongs_to_primary_key_quoting
  con = Account.connection
  assert_sql(/#{con.quote_table_name('companies')}.#{con.quote_column_name('id')} IN \(1\)/) do
    Account.find(1, :include => :firm)
  end
end

# File activerecord/test/cases/inheritance_test.rb, line 212
def test_eager_load_belongs_to_something_inherited
  account = Account.find(1, :include => :firm)
  assert account.association_cache.key?(:firm), "nil proves eager load failed"
end

# File activerecord/test/cases/inheritance_test.rb, line 184
def test_find_first_within_inheritance
  assert_kind_of Firm, Company.find(:first, :conditions => "name = '37signals'")
  assert_kind_of Firm, Firm.find(:first, :conditions => "name = '37signals'")
  assert_nil Client.find(:first, :conditions => "name = '37signals'")
end

# File activerecord/test/cases/inheritance_test.rb, line 148
def test_finding_incorrect_type_data
  assert_raise(ActiveRecord::RecordNotFound) { Firm.find(2) }
  assert_nothing_raised   { Firm.find(1) }
end

# File railties/lib/rails/generators/test_unit/performance/templates/performance_test.rb, line 9
def test_homepage
  get '/'
end

# File activerecord/test/cases/inheritance_test.rb, line 136
def test_inheritance_condition
  assert_equal 10, Company.count
  assert_equal 2, Firm.count
  assert_equal 4, Client.count
end

# File activerecord/test/cases/inheritance_test.rb, line 89
def test_inheritance_find
  assert_kind_of Firm, Company.find(1), "37signals should be a firm"
  assert_kind_of Firm, Firm.find(1), "37signals should be a firm"
  assert_kind_of Client, Company.find(2), "Summit should be a client"
  assert_kind_of Client, Client.find(2), "Summit should be a client"
end

# File activerecord/test/cases/inheritance_test.rb, line 109
def test_inheritance_find_all
  companies = Company.find(:all, :order => 'id')
  assert_kind_of Firm, companies[0], "37signals should be a firm"
  assert_kind_of Client, companies[1], "Summit should be a client"
end

# File activerecord/test/cases/inheritance_test.rb, line 121
def test_inheritance_save
  firm = Firm.new
  firm.name = "Next Angle"
  firm.save

  next_angle = Company.find(firm.id)
  assert_kind_of Firm, next_angle, "Next Angle should be a firm"
end

# File activerecord/test/cases/inheritance_test.rb, line 234
def test_inheritance_without_mapping
  assert_kind_of SpecialSubscriber, SpecialSubscriber.find("webster132")
  assert_nothing_raised { s = SpecialSubscriber.new("name" => "And breaaaaathe!"); s.id = 'roger'; s.save }
end

# File activerecord/test/cases/inheritance_test.rb, line 230
def test_inherits_custom_primary_key
  assert_equal Subscriber.primary_key, SpecialSubscriber.primary_key
end

# File activerecord/test/cases/inheritance_test.rb, line 239
def test_scope_inherited_properly
  assert_nothing_raised { Company.of_first_firm }
  assert_nothing_raised { Client.of_first_firm }
end

# File activerecord/test/cases/inheritance_test.rb, line 40
def test_should_store_demodulized_class_name_with_store_full_sti_class_option_disabled
  old = ActiveRecord::Base.store_full_sti_class
  ActiveRecord::Base.store_full_sti_class = false
  item = Namespaced::Company.new
  assert_equal 'Company', item[:type]
ensure
  ActiveRecord::Base.store_full_sti_class = old
end

# File activerecord/test/cases/inheritance_test.rb, line 49
def test_should_store_full_class_name_with_store_full_sti_class_option_enabled
  old = ActiveRecord::Base.store_full_sti_class
  ActiveRecord::Base.store_full_sti_class = true
  item = Namespaced::Company.new
  assert_equal 'Namespaced::Company', item[:type]
ensure
  ActiveRecord::Base.store_full_sti_class = old
end

# File activerecord/test/cases/inheritance_test.rb, line 159
def test_update_all_within_inheritance
  Client.update_all "name = 'I am a client'"
  assert_equal "I am a client", Client.find(:all).first.name
  # Order by added as otherwise Oracle tests were failing because of different order of results
  assert_equal "37signals", Firm.find(:all, :order => "id").first.name
end

# File activesupport/lib/active_support/core_ext/object/to_json.rb, line 15
def to_json(options = nil)
  ActiveSupport::JSON.encode(self, options)
end

# File activesupport/lib/active_support/core_ext/object/to_param.rb, line 3
def to_param
  to_s
end

# File activesupport/lib/active_support/core_ext/object/to_query.rb, line 8
def to_query(key)
  require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
  "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
end

# File activesupport/lib/active_support/core_ext/object/try.rb, line 32
def try(*a, &b)
  if a.empty? && block_given?
    yield self
  else
    __send__(*a, &b)
  end
end

# File activesupport/lib/active_support/core_ext/uri.rb, line 12
def unescape(str, escaped = /%[a-fA-F\d]{2}/)
  # TODO: Are we actually sure that ASCII == UTF-8?
  # YK: My initial experiments say yes, but let's be sure please
  enc = str.encoding
  enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
  str.gsub(escaped) { [$&[1, 2].hex].pack('C') }.force_encoding(enc)
end

# File activesupport/test/abstract_unit.rb, line 36
def uses_memcached(test_name)
  require 'memcache'
  begin
    MemCache.new('localhost:11211').stats
    yield
  rescue MemCache::MemCacheError
    $stderr.puts "Skipping #{test_name} tests. Start memcached and try again."
  end
end

# File activerecord/test/cases/helper.rb, line 52
def with_active_record_default_timezone(zone)
  old_zone, ActiveRecord::Base.default_timezone = ActiveRecord::Base.default_timezone, zone
  yield
ensure
  ActiveRecord::Base.default_timezone = old_zone
end

# File activerecord/test/cases/helper.rb, line 45
def with_env_tz(new_tz = 'US/Eastern')
  old_tz, ENV['TZ'] = ENV['TZ'], new_tz
  yield
ensure
  old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
end

# File activesupport/test/abstract_unit.rb, line 46
def with_kcode(code)
  if RUBY_VERSION < '1.9'
    begin
      old_kcode, $KCODE = $KCODE, code
      yield
    ensure
      $KCODE = old_kcode
    end
  else
    yield
  end
end

# File activesupport/lib/active_support/core_ext/object/with_options.rb, line 40
def with_options(options)
  yield ActiveSupport::OptionMerger.new(self, options)
end