opal-activesupport 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87d2b460105407cc966e27d833b627f9f35922e1
-  data.tar.gz: 5c55b9cc4c9093242d4944dcf1d414f1f5b9c6a9
+  metadata.gz: 0f50583cfaec84405d53bde416f3145fb999d402
+  data.tar.gz: 43cea084988895bc552064b795ac347e505b7475
 SHA512:
-  metadata.gz: 95d565c00c6a4628ed6baa96cfc735525b76dae8fe3ca8eb985479c936dec6213f1105dd6831ee4bfeea45f08251f16c3c682f13df0d9f32f01031d33abc32c7
-  data.tar.gz: 6b4f61e61dd0ef07188ea84f940dd781144dc64e5965e035be4676d33aea6c4f5c5e95a8cb77b67f6f4f7e1796ae3e93f4633331e606b1a965154a94f92cb960
+  metadata.gz: 714a1afc7c2c4cf6d19204b94fd4755e4481df11ee9d79cdbeeaa7d49b8798ce1149e02d557b590649cc2417314ba207c168958a1af4f08fe8a659370ac6fcd8
+  data.tar.gz: 73b58de9570c085e1ef0bfd01433177ac0cc16ff71f957bf5c0a3935c339c06d888c80ce64d86ddbdb3cdc3d8aa0f41725a69bbe0d966bc5cc667a6416c94a1d

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+
+sudo: false
+
+cache:
+  bundler: true
+

data/Rakefile

@@ -1,7 +1,14 @@
 require 'bundler'
 Bundler.require
 
-require 'opal/rspec/rake_task'
-Opal::RSpec::RakeTask.new(:default)
+require 'opal/minitest/rake_task'
+# Opal::Minitest::RakeTask.new
+
+task :test do
+  files = Dir['test/**/*_test.rb'].map {|f| "-r #{f.chomp('.rb').sub(/^test\//, '')}"}
+  sh "bundle exec ruby -r opal/minitest -S opal -Dwarning -Itest -Iopal #{files.join(' ')} -e puts"
+end
+
+task default: :test
 
 require 'bundler/gem_tasks'

data/lib/opal/activesupport/version.rb

@@ -1,5 +1,5 @@
 module Opal
   module Activesupport
-    VERSION = '0.2.0'
+    VERSION = '0.3.0'
   end
 end

data/opal-activesupport.gemspec

@@ -21,6 +21,6 @@ Gem::Specification.new do |gem|
   gem.require_paths = ['lib']
 
   gem.add_dependency 'opal', ['>= 0.5.0', '< 1.0.0']
-  gem.add_development_dependency 'opal-rspec', '~> 0.4.0'
+  gem.add_development_dependency 'opal-minitest'
   gem.add_development_dependency 'rake'
 end

data/opal/active_support/core_ext/array.rb

@@ -1 +1,3 @@
 require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/array/grouping'

data/opal/active_support/core_ext/array/grouping.rb

@@ -0,0 +1,99 @@
+class Array
+  # Splits or iterates over the array in groups of size +number+,
+  # padding any remaining slots with +fill_with+ unless it is +false+.
+  #
+  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups_of(3) {|group| p group}
+  #   ["1", "2", "3"]
+  #   ["4", "5", "6"]
+  #   ["7", "8", "9"]
+  #   ["10", nil, nil]
+  #
+  #   %w(1 2 3 4 5).in_groups_of(2, ' ') {|group| p group}
+  #   ["1", "2"]
+  #   ["3", "4"]
+  #   ["5", " "]
+  #
+  #   %w(1 2 3 4 5).in_groups_of(2, false) {|group| p group}
+  #   ["1", "2"]
+  #   ["3", "4"]
+  #   ["5"]
+  def in_groups_of(number, fill_with = nil)
+    if fill_with == false
+      collection = self
+    else
+      # size % number gives how many extra we have;
+      # subtracting from number gives how many to add;
+      # modulo number ensures we don't add group of just fill.
+      padding = (number - size % number) % number
+      collection = dup.concat([fill_with] * padding)
+    end
+
+    if block_given?
+      collection.each_slice(number) { |slice| yield(slice) }
+    else
+      groups = []
+      collection.each_slice(number) { |group| groups << group }
+      groups
+    end
+  end
+
+  # Splits or iterates over the array in +number+ of groups, padding any
+  # remaining slots with +fill_with+ unless it is +false+.
+  #
+  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups(3) {|group| p group}
+  #   ["1", "2", "3", "4"]
+  #   ["5", "6", "7", nil]
+  #   ["8", "9", "10", nil]
+  #
+  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups(3, '&nbsp;') {|group| p group}
+  #   ["1", "2", "3", "4"]
+  #   ["5", "6", "7", "&nbsp;"]
+  #   ["8", "9", "10", "&nbsp;"]
+  #
+  #   %w(1 2 3 4 5 6 7).in_groups(3, false) {|group| p group}
+  #   ["1", "2", "3"]
+  #   ["4", "5"]
+  #   ["6", "7"]
+  def in_groups(number, fill_with = nil)
+    # size / number gives minor group size;
+    # size % number gives how many objects need extra accommodation;
+    # each group hold either division or division + 1 items.
+    division = size.div number
+    modulo = size % number
+
+    # create a new array avoiding dup
+    groups = []
+    start = 0
+
+    number.times do |index|
+      length = division + (modulo > 0 && modulo > index ? 1 : 0)
+      groups << last_group = slice(start, length)
+      last_group << fill_with if fill_with != false &&
+        modulo > 0 && length == division
+      start += length
+    end
+
+    if block_given?
+      groups.each { |g| yield(g) }
+    else
+      groups
+    end
+  end
+
+  # Divides the array into one or more subarrays based on a delimiting +value+
+  # or the result of an optional block.
+  #
+  #   [1, 2, 3, 4, 5].split(3)              # => [[1, 2], [4, 5]]
+  #   (1..10).to_a.split { |i| i % 3 == 0 } # => [[1, 2], [4, 5], [7, 8], [10]]
+  def split(value = nil, &block)
+    inject([[]]) do |results, element|
+      if block && block.call(element) || value == element
+        results << []
+      else
+        results.last << element
+      end
+
+      results
+    end
+  end
+end

data/opal/active_support/core_ext/array/wrap.rb

@@ -0,0 +1,45 @@
+class Array
+  # Wraps its argument in an array unless it is already an array (or array-like).
+  #
+  # Specifically:
+  #
+  # * If the argument is +nil+ an empty list is returned.
+  # * Otherwise, if the argument responds to +to_ary+ it is invoked, and its result returned.
+  # * Otherwise, returns an array with the argument as its single element.
+  #
+  #     Array.wrap(nil)       # => []
+  #     Array.wrap([1, 2, 3]) # => [1, 2, 3]
+  #     Array.wrap(0)         # => [0]
+  #
+  # This method is similar in purpose to <tt>Kernel#Array</tt>, but there are some differences:
+  #
+  # * If the argument responds to +to_ary+ the method is invoked. <tt>Kernel#Array</tt>
+  #   moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
+  #   such a +nil+ right away.
+  # * If the returned value from +to_ary+ is neither +nil+ nor an +Array+ object, <tt>Kernel#Array</tt>
+  #   raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
+  # * It does not call +to_a+ on the argument, though special-cases +nil+ to return an empty array.
+  #
+  # The last point is particularly worth comparing for some enumerables:
+  #
+  #   Array(foo: :bar)      # => [[:foo, :bar]]
+  #   Array.wrap(foo: :bar) # => [{:foo=>:bar}]
+  #
+  # There's also a related idiom that uses the splat operator:
+  #
+  #   [*object]
+  #
+  # which for +nil+ returns <tt>[]</tt>, and calls to <tt>Array(object)</tt> otherwise.
+  #
+  # Thus, in this case the behavior may be different for +nil+, and the differences with
+  # <tt>Kernel#Array</tt> explained above apply to the rest of <tt>object</tt>s.
+  def self.wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary || [object]
+    else
+      [object]
+    end
+  end
+end

data/opal/active_support/core_ext/module.rb

@@ -1 +1,3 @@
+require 'active_support/core_ext/module/introspection'
 require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/module/delegation'

data/opal/active_support/core_ext/module/delegation.rb

@@ -0,0 +1,64 @@
+class Module
+  class DelegationError < NoMethodError;
+  end
+
+  def delegate(*methods)
+    options = methods.pop
+    unless options.is_a?(Hash) && to = options[:to]
+      raise ArgumentError, 'Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, to: :greeter).'
+    end
+
+    prefix, allow_nil = options.values_at(:prefix, :allow_nil)
+
+    if prefix == true && to =~ /^[^a-z_]/
+      raise ArgumentError, 'Can only automatically set the delegation prefix when delegating to a method.'
+    end
+
+    method_prefix = if prefix
+                      "#{prefix == true ? to : prefix}_"
+                    else
+                      ''
+                    end
+
+    to = to.to_s
+
+    methods.each do |method|
+      # Attribute writer methods only accept one argument. Makes sure []=
+      # methods still accept two arguments.
+      has_block = (method =~ /[^\]]=$/) ? false : true
+      method_name = method_prefix + method
+      # Avoiding the eval approach rails/active_support takes since it was brittle with making this work
+      resolve_to = lambda do |scope|
+        if to.start_with?('@')
+          ivar_name = to[1..-1]
+          # Had problems with instance_variable_get
+          `#{scope}[#{ivar_name}]`
+        else
+          scope.__send__(to)
+        end
+      end
+      exception = lambda do |scope|
+        DelegationError.new("#{scope}#{method_name} delegated to #{to}.#{method} but #{to} is nil: #{scope.inspect}", method_name)
+      end
+      if has_block
+        define_method(method_name) do |*args, &block|
+          to_resolved = resolve_to[self]
+          unless to_resolved
+            next if allow_nil
+            raise exception[self]
+          end
+          to_resolved.__send__(method, *args, &block)
+        end
+      else
+        define_method(method_name) do |arg|
+          to_resolved = resolve_to[self]
+          unless to_resolved
+            next if allow_nil
+            raise exception[self]
+          end
+          to_resolved.__send__(method, arg)
+        end
+      end
+    end
+  end
+end

data/opal/active_support/core_ext/module/introspection.rb

@@ -0,0 +1,62 @@
+require 'active_support/inflector'
+
+class Module
+  # Returns the name of the module containing this one.
+  #
+  #   M::N.parent_name # => "M"
+  def parent_name
+    if defined? @parent_name
+      @parent_name
+    else
+      @parent_name = name =~ /::[^:]+$/ ? $`.freeze : nil
+    end
+  end
+
+  # Returns the module which contains this one according to its name.
+  #
+  #   module M
+  #     module N
+  #     end
+  #   end
+  #   X = M::N
+  #
+  #   M::N.parent # => M
+  #   X.parent    # => M
+  #
+  # The parent of top-level and anonymous modules is Object.
+  #
+  #   M.parent          # => Object
+  #   Module.new.parent # => Object
+  def parent
+    parent_name ? ActiveSupport::Inflector.constantize(parent_name) : Object
+  end
+
+  # Returns all the parents of this module according to its name, ordered from
+  # nested outwards. The receiver is not contained within the result.
+  #
+  #   module M
+  #     module N
+  #     end
+  #   end
+  #   X = M::N
+  #
+  #   M.parents    # => [Object]
+  #   M::N.parents # => [M, Object]
+  #   X.parents    # => [M, Object]
+  def parents
+    parents = []
+    if parent_name
+      parts = parent_name.split('::')
+      until parts.empty?
+        parents << ActiveSupport::Inflector.constantize(parts * '::')
+        parts.pop
+      end
+    end
+    parents << Object unless parents.include? Object
+    parents
+  end
+
+  def local_constants #:nodoc:
+    constants(false)
+  end
+end

data/test/abstract_unit.rb

@@ -0,0 +1,46 @@
+# ORIG_ARGV = ARGV.dup
+#
+# begin
+#   old, $VERBOSE = $VERBOSE, nil
+#   require File.expand_path('../../../load_paths', __FILE__)
+# ensure
+#   $VERBOSE = old
+# end
+#
+# require 'active_support/core_ext/kernel/reporting'
+# require 'active_support/core_ext/string/encoding'
+#
+# silence_warnings do
+#   Encoding.default_internal = "UTF-8"
+#   Encoding.default_external = "UTF-8"
+# end
+#
+# require 'active_support/testing/autorun'
+# require 'empty_bool'
+#
+# ENV['NO_RELOAD'] = '1'
+# require 'active_support'
+#
+# Thread.abort_on_exception = true
+#
+# # Show backtraces for deprecated behavior for quicker cleanup.
+# ActiveSupport::Deprecation.debug = true
+
+require 'minitest/autorun'
+require 'empty_bool'
+require 'active_support'
+
+class ActiveSupport::TestCase < Minitest::Test
+  def self.test name, &block
+    define_method "test_#{name.gsub(/[\W-]+/, '_')}", &block
+  end
+
+  def assert_raise error, &block
+    block.call
+    assert false, "Expected to see #{error.inspect}, but no exception was raised"
+  rescue error
+    # noop
+  rescue => actual_error
+    assert false, "Expected to see #{error.inspect}, but got #{actual_error.inspect}"
+  end
+end

data/test/core_ext/array_ext_test.rb

@@ -0,0 +1,471 @@
+require 'abstract_unit'
+require 'active_support/core_ext/array'
+# require 'active_support/core_ext/big_decimal'
+# require 'active_support/core_ext/object/conversions'
+
+require 'active_support/core_ext' # FIXME: pulling in all to_xml extensions
+require 'active_support/hash_with_indifferent_access'
+
+# class ArrayExtAccessTests < ActiveSupport::TestCase
+#   def test_from
+#     assert_equal %w( a b c d ), %w( a b c d ).from(0)
+#     assert_equal %w( c d ), %w( a b c d ).from(2)
+#     assert_equal %w(), %w( a b c d ).from(10)
+#   end
+#
+#   def test_to
+#     assert_equal %w( a ), %w( a b c d ).to(0)
+#     assert_equal %w( a b c ), %w( a b c d ).to(2)
+#     assert_equal %w( a b c d ), %w( a b c d ).to(10)
+#   end
+#
+#   def test_second_through_tenth
+#     array = (1..42).to_a
+#
+#     assert_equal array[1], array.second
+#     assert_equal array[2], array.third
+#     assert_equal array[3], array.fourth
+#     assert_equal array[4], array.fifth
+#     assert_equal array[41], array.forty_two
+#   end
+# end
+#
+# class ArrayExtToParamTests < ActiveSupport::TestCase
+#   class ToParam < String
+#     def to_param
+#       "#{self}1"
+#     end
+#   end
+#
+#   def test_string_array
+#     assert_equal '', %w().to_param
+#     assert_equal 'hello/world', %w(hello world).to_param
+#     assert_equal 'hello/10', %w(hello 10).to_param
+#   end
+#
+#   def test_number_array
+#     assert_equal '10/20', [10, 20].to_param
+#   end
+#
+#   def test_to_param_array
+#     assert_equal 'custom1/param1', [ToParam.new('custom'), ToParam.new('param')].to_param
+#   end
+# end
+#
+# class ArrayExtToSentenceTests < ActiveSupport::TestCase
+#   def test_plain_array_to_sentence
+#     assert_equal "", [].to_sentence
+#     assert_equal "one", ['one'].to_sentence
+#     assert_equal "one and two", ['one', 'two'].to_sentence
+#     assert_equal "one, two, and three", ['one', 'two', 'three'].to_sentence
+#   end
+#
+#   def test_to_sentence_with_words_connector
+#     assert_equal "one two, and three", ['one', 'two', 'three'].to_sentence(:words_connector => ' ')
+#     assert_equal "one & two, and three", ['one', 'two', 'three'].to_sentence(:words_connector => ' & ')
+#     assert_equal "onetwo, and three", ['one', 'two', 'three'].to_sentence(:words_connector => nil)
+#   end
+#
+#   def test_to_sentence_with_last_word_connector
+#     assert_equal "one, two, and also three", ['one', 'two', 'three'].to_sentence(:last_word_connector => ', and also ')
+#     assert_equal "one, twothree", ['one', 'two', 'three'].to_sentence(:last_word_connector => nil)
+#     assert_equal "one, two three", ['one', 'two', 'three'].to_sentence(:last_word_connector => ' ')
+#     assert_equal "one, two and three", ['one', 'two', 'three'].to_sentence(:last_word_connector => ' and ')
+#   end
+#
+#   def test_two_elements
+#     assert_equal "one and two", ['one', 'two'].to_sentence
+#     assert_equal "one two", ['one', 'two'].to_sentence(:two_words_connector => ' ')
+#   end
+#
+#   def test_one_element
+#     assert_equal "one", ['one'].to_sentence
+#   end
+#
+#   def test_one_element_not_same_object
+#     elements = ["one"]
+#     assert_not_equal elements[0].object_id, elements.to_sentence.object_id
+#   end
+#
+#   def test_one_non_string_element
+#     assert_equal '1', [1].to_sentence
+#   end
+#
+#   def test_does_not_modify_given_hash
+#     options = { words_connector: ' ' }
+#     assert_equal "one two, and three", ['one', 'two', 'three'].to_sentence(options)
+#     assert_equal({ words_connector: ' ' }, options)
+#   end
+# end
+#
+# class ArrayExtToSTests < ActiveSupport::TestCase
+#   def test_to_s_db
+#     collection = [
+#       Class.new { def id() 1 end }.new,
+#       Class.new { def id() 2 end }.new,
+#       Class.new { def id() 3 end }.new
+#     ]
+#
+#     assert_equal "null", [].to_s(:db)
+#     assert_equal "1,2,3", collection.to_s(:db)
+#   end
+# end
+
+class ArrayExtGroupingTests < ActiveSupport::TestCase
+  def setup
+    Fixnum.send :private, :/  # test we avoid Integer#/ (redefined by mathn)
+  end
+
+  def teardown
+    Fixnum.send :public, :/
+  end
+
+  def test_in_groups_of_with_perfect_fit
+    groups = []
+    ('a'..'i').to_a.in_groups_of(3) do |group|
+      groups << group
+    end
+
+    assert_equal [%w(a b c), %w(d e f), %w(g h i)], groups
+    assert_equal [%w(a b c), %w(d e f), %w(g h i)], ('a'..'i').to_a.in_groups_of(3)
+  end
+
+  def test_in_groups_of_with_padding
+    groups = []
+    ('a'..'g').to_a.in_groups_of(3) do |group|
+      groups << group
+    end
+
+    assert_equal [%w(a b c), %w(d e f), ['g', nil, nil]], groups
+  end
+
+  def test_in_groups_of_pads_with_specified_values
+    groups = []
+
+    ('a'..'g').to_a.in_groups_of(3, 'foo') do |group|
+      groups << group
+    end
+
+    assert_equal [%w(a b c), %w(d e f), ['g', 'foo', 'foo']], groups
+  end
+
+  def test_in_groups_of_without_padding
+    groups = []
+
+    ('a'..'g').to_a.in_groups_of(3, false) do |group|
+      groups << group
+    end
+
+    assert_equal [%w(a b c), %w(d e f), ['g']], groups
+  end
+
+  def test_in_groups_returned_array_size
+    array = (1..7).to_a
+
+    1.upto(array.size + 1) do |number|
+      assert_equal number, array.in_groups(number).size
+    end
+  end
+
+  def test_in_groups_with_empty_array
+    assert_equal [[], [], []], [].in_groups(3)
+  end
+
+  def test_in_groups_with_block
+    array = (1..9).to_a
+    groups = []
+
+    array.in_groups(3) do |group|
+      groups << group
+    end
+
+    assert_equal array.in_groups(3), groups
+  end
+
+  def test_in_groups_with_perfect_fit
+    assert_equal [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+      (1..9).to_a.in_groups(3)
+  end
+
+  def test_in_groups_with_padding
+    array = (1..7).to_a
+
+    assert_equal [[1, 2, 3], [4, 5, nil], [6, 7, nil]],
+      array.in_groups(3)
+    assert_equal [[1, 2, 3], [4, 5, 'foo'], [6, 7, 'foo']],
+      array.in_groups(3, 'foo')
+  end
+
+  def test_in_groups_without_padding
+    assert_equal [[1, 2, 3], [4, 5], [6, 7]],
+      (1..7).to_a.in_groups(3, false)
+  end
+end
+
+class ArraySplitTests < ActiveSupport::TestCase
+  def test_split_with_empty_array
+    assert_equal [[]], [].split(0)
+  end
+
+  def test_split_with_argument
+    assert_equal [[1, 2], [4, 5]],  [1, 2, 3, 4, 5].split(3)
+    assert_equal [[1, 2, 3, 4, 5]], [1, 2, 3, 4, 5].split(0)
+  end
+
+  def test_split_with_block
+    assert_equal [[1, 2], [4, 5], [7, 8], [10]], (1..10).to_a.split { |i| i % 3 == 0 }
+  end
+
+  def test_split_with_edge_values
+    assert_equal [[], [2, 3, 4, 5]],  [1, 2, 3, 4, 5].split(1)
+    assert_equal [[1, 2, 3, 4], []],  [1, 2, 3, 4, 5].split(5)
+    assert_equal [[], [2, 3, 4], []], [1, 2, 3, 4, 5].split { |i| i == 1 || i == 5 }
+  end
+end
+
+# class ArrayToXmlTests < ActiveSupport::TestCase
+#   def test_to_xml
+#     xml = [
+#       { :name => "David", :age => 26, :age_in_millis => 820497600000 },
+#       { :name => "Jason", :age => 31, :age_in_millis => BigDecimal.new('1.0') }
+#     ].to_xml(:skip_instruct => true, :indent => 0)
+#
+#     assert_equal '<objects type="array"><object>', xml.first(30)
+#     assert xml.include?(%(<age type="integer">26</age>)), xml
+#     assert xml.include?(%(<age-in-millis type="integer">820497600000</age-in-millis>)), xml
+#     assert xml.include?(%(<name>David</name>)), xml
+#     assert xml.include?(%(<age type="integer">31</age>)), xml
+#     assert xml.include?(%(<age-in-millis type="decimal">1.0</age-in-millis>)), xml
+#     assert xml.include?(%(<name>Jason</name>)), xml
+#   end
+#
+#   def test_to_xml_with_dedicated_name
+#     xml = [
+#       { :name => "David", :age => 26, :age_in_millis => 820497600000 }, { :name => "Jason", :age => 31 }
+#     ].to_xml(:skip_instruct => true, :indent => 0, :root => "people")
+#
+#     assert_equal '<people type="array"><person>', xml.first(29)
+#   end
+#
+#   def test_to_xml_with_options
+#     xml = [
+#       { :name => "David", :street_address => "Paulina" }, { :name => "Jason", :street_address => "Evergreen" }
+#     ].to_xml(:skip_instruct => true, :skip_types => true, :indent => 0)
+#
+#     assert_equal "<objects><object>", xml.first(17)
+#     assert xml.include?(%(<street-address>Paulina</street-address>))
+#     assert xml.include?(%(<name>David</name>))
+#     assert xml.include?(%(<street-address>Evergreen</street-address>))
+#     assert xml.include?(%(<name>Jason</name>))
+#   end
+#
+#   def test_to_xml_with_dasherize_false
+#     xml = [
+#       { :name => "David", :street_address => "Paulina" }, { :name => "Jason", :street_address => "Evergreen" }
+#     ].to_xml(:skip_instruct => true, :skip_types => true, :indent => 0, :dasherize => false)
+#
+#     assert_equal "<objects><object>", xml.first(17)
+#     assert xml.include?(%(<street_address>Paulina</street_address>))
+#     assert xml.include?(%(<street_address>Evergreen</street_address>))
+#   end
+#
+#   def test_to_xml_with_dasherize_true
+#     xml = [
+#       { :name => "David", :street_address => "Paulina" }, { :name => "Jason", :street_address => "Evergreen" }
+#     ].to_xml(:skip_instruct => true, :skip_types => true, :indent => 0, :dasherize => true)
+#
+#     assert_equal "<objects><object>", xml.first(17)
+#     assert xml.include?(%(<street-address>Paulina</street-address>))
+#     assert xml.include?(%(<street-address>Evergreen</street-address>))
+#   end
+#
+#   def test_to_with_instruct
+#     xml = [
+#       { :name => "David", :age => 26, :age_in_millis => 820497600000 },
+#       { :name => "Jason", :age => 31, :age_in_millis => BigDecimal.new('1.0') }
+#     ].to_xml(:skip_instruct => false, :indent => 0)
+#
+#     assert_match(/^<\?xml [^>]*/, xml)
+#     assert_equal 0, xml.rindex(/<\?xml /)
+#   end
+#
+#   def test_to_xml_with_block
+#     xml = [
+#       { :name => "David", :age => 26, :age_in_millis => 820497600000 },
+#       { :name => "Jason", :age => 31, :age_in_millis => BigDecimal.new('1.0') }
+#     ].to_xml(:skip_instruct => true, :indent => 0) do |builder|
+#       builder.count 2
+#     end
+#
+#     assert xml.include?(%(<count>2</count>)), xml
+#   end
+#
+#   def test_to_xml_with_empty
+#     xml = [].to_xml
+#     assert_match(/type="array"\/>/, xml)
+#   end
+#
+#   def test_to_xml_dups_options
+#     options = {:skip_instruct => true}
+#     [].to_xml(options)
+#     # :builder, etc, shouldn't be added to options
+#     assert_equal({:skip_instruct => true}, options)
+#   end
+# end
+
+class ArrayExtractOptionsTests < ActiveSupport::TestCase
+  class HashSubclass < Hash
+  end
+
+  class ExtractableHashSubclass < Hash
+    def extractable_options?
+      true
+    end
+  end
+
+  def test_extract_options
+    assert_equal({}, [].extract_options!)
+    assert_equal({}, [1].extract_options!)
+    assert_equal({:a=>:b}, [{:a=>:b}].extract_options!)
+    assert_equal({:a=>:b}, [1, {:a=>:b}].extract_options!)
+  end
+
+  def test_extract_options_doesnt_extract_hash_subclasses
+    hash = HashSubclass.new
+    hash[:foo] = 1
+    array = [hash]
+    options = array.extract_options!
+    assert_equal({}, options)
+    assert_equal [hash], array
+  end
+
+  def test_extract_options_extracts_extractable_subclass
+    hash = ExtractableHashSubclass.new
+    hash[:foo] = 1
+    array = [hash]
+    options = array.extract_options!
+    assert_equal({:foo => 1}, options)
+    assert_equal [], array
+  end
+
+  def test_extract_options_extracts_hwia
+    hash = [{:foo => 1}.with_indifferent_access]
+    options = hash.extract_options!
+    assert_equal 1, options[:foo]
+  end
+end
+
+# class ArrayUniqByTests < ActiveSupport::TestCase
+#   def test_uniq_by
+#     ActiveSupport::Deprecation.silence do
+#       assert_equal [1,2], [1,2,3,4].uniq_by { |i| i.odd? }
+#       assert_equal [1,2], [1,2,3,4].uniq_by(&:even?)
+#       assert_equal((-5..0).to_a, (-5..5).to_a.uniq_by{ |i| i**2 })
+#     end
+#   end
+#
+#   def test_uniq_by!
+#     a = [1,2,3,4]
+#     ActiveSupport::Deprecation.silence do
+#       a.uniq_by! { |i| i.odd? }
+#     end
+#     assert_equal [1,2], a
+#
+#     a = [1,2,3,4]
+#     ActiveSupport::Deprecation.silence do
+#       a.uniq_by! { |i| i.even? }
+#     end
+#     assert_equal [1,2], a
+#
+#     a = (-5..5).to_a
+#     ActiveSupport::Deprecation.silence do
+#       a.uniq_by! { |i| i**2 }
+#     end
+#     assert_equal((-5..0).to_a, a)
+#   end
+# end
+
+class ArrayWrapperTests < ActiveSupport::TestCase
+  class FakeCollection
+    def to_ary
+      ["foo", "bar"]
+    end
+  end
+
+  class Proxy
+    def initialize(target) @target = target end
+    def method_missing(*a) @target.send(*a) end
+  end
+
+  class DoubtfulToAry
+    def to_ary
+      :not_an_array
+    end
+  end
+
+  class NilToAry
+    def to_ary
+      nil
+    end
+  end
+
+  def test_array
+    ary = %w(foo bar)
+    assert_same ary, Array.wrap(ary)
+  end
+
+  def test_nil
+    assert_equal [], Array.wrap(nil)
+  end
+
+  def test_object
+    o = Object.new
+    assert_equal [o], Array.wrap(o)
+  end
+
+  def test_string
+    assert_equal ["foo"], Array.wrap("foo")
+  end
+
+  def test_string_with_newline
+    assert_equal ["foo\nbar"], Array.wrap("foo\nbar")
+  end
+
+  def test_object_with_to_ary
+    assert_equal ["foo", "bar"], Array.wrap(FakeCollection.new)
+  end
+
+  def test_proxy_object
+    p = Proxy.new(Object.new)
+    assert_equal [p], Array.wrap(p)
+  end
+
+  def test_proxy_to_object_with_to_ary
+    p = Proxy.new(FakeCollection.new)
+    assert_equal [p], Array.wrap(p)
+  end
+
+  def test_struct
+    o = Struct.new(:foo).new(123)
+    assert_equal [o], Array.wrap(o)
+  end
+
+  def test_wrap_returns_wrapped_if_to_ary_returns_nil
+    o = NilToAry.new
+    assert_equal [o], Array.wrap(o)
+  end
+
+  def test_wrap_does_not_complain_if_to_ary_does_not_return_an_array
+    assert_equal DoubtfulToAry.new.to_ary, Array.wrap(DoubtfulToAry.new)
+  end
+end
+
+# class ArrayPrependAppendTest < ActiveSupport::TestCase
+#   def test_append
+#     assert_equal [1, 2], [1].append(2)
+#   end
+#
+#   def test_prepend
+#     assert_equal [2, 1], [1].prepend(2)
+#   end
+# end