kronk 1.8.5 → 1.8.6

data/test/test_path_matcher.rb

@@ -1,371 +0,0 @@
-require 'test/test_helper'
-
-class TestPathMatcher < Test::Unit::TestCase
-
-  def setup
-    @matcher = Kronk::Path::Matcher.new :key => "foo*", :value => "*bar*"
-    @data = {
-      :key1 => {
-        :key1a => [
-          "foo",
-          "bar",
-          "foobar",
-          {:findme => "thing"}
-        ],
-        'key1b' => "findme"
-      },
-      'findme' => [
-        123,
-        456,
-        {:findme => 123456}
-      ],
-      :key2 => "foobar",
-      :key3 => {
-        :key3a => ["val1", "val2", "val3"]
-      }
-    }
-  end
-
-
-  def test_new
-    assert_equal %r{\A(?:foo(.*))\Z},     @matcher.key
-    assert_equal %r{\A(?:(.*)bar(.*))\Z}, @matcher.value
-    assert !@matcher.recursive
-  end
-
-
-
-  def test_each_data_item_hash
-    hash = {
-      :a => 1,
-      :b => 2,
-      :c => 3
-    }
-
-    keys = []
-    values = []
-
-    @matcher.each_data_item hash do |key, val|
-      keys << key
-      values << val
-    end
-
-    assert_equal keys, (keys | hash.keys)
-    assert_equal values, (values | hash.values)
-  end
-
-
-  def test_each_data_item_array
-    ary = [:a, :b, :c]
-
-    keys = []
-    values = []
-
-    @matcher.each_data_item ary do |key, val|
-      keys << key
-      values << val
-    end
-
-    assert_equal [2,1,0], keys
-    assert_equal ary.reverse, values
-  end
-
-
-  def test_match_node
-    assert @matcher.match_node(:key, "key")
-    assert @matcher.match_node("key", :key)
-
-    assert @matcher.match_node(/key/, "foo_key")
-    assert !@matcher.match_node("foo_key", /key/)
-    assert @matcher.match_node(/key/, /key/)
-
-    assert @matcher.match_node(Kronk::Path::Matcher::ANY_VALUE, "foo_key")
-    assert !@matcher.match_node("foo_key", Kronk::Path::Matcher::ANY_VALUE)
-
-    assert @matcher.match_node(1..3, 1)
-    assert !@matcher.match_node(1, 1..3)
-    assert @matcher.match_node(1..3, 1..3)
-  end
-
-
-  def test_find_in
-    keys = []
-
-    Kronk::Path::Matcher.new(:key => /key/).find_in @data do |data, key|
-      keys << key.to_s
-      assert_equal @data, data
-    end
-
-    assert_equal ['key1', 'key2', 'key3'], keys.sort
-  end
-
-
-  def test_find_in_recursive
-    keys = []
-    data_points = []
-
-    matcher = Kronk::Path::Matcher.new :key       => :findme,
-                                       :recursive => true
-
-    path_matches = matcher.find_in @data do |data, key|
-      keys << key.to_s
-      data_points << data
-    end
-
-    assert path_matches.find{|pm| pm.splat == [[matcher, [:key1, :key1a, 3]]]}
-    assert_equal 3, keys.length
-    assert_equal 1, keys.uniq.length
-    assert_equal "findme", keys.first
-
-    assert_equal 3, data_points.length
-    assert data_points.include?(@data)
-    assert data_points.include?({:findme => "thing"})
-    assert data_points.include?({:findme => 123456})
-  end
-
-
-  def test_find_in_value
-    keys = []
-    data_points = []
-
-    matcher = Kronk::Path::Matcher.new :key => "*", :value => "findme"
-    matcher.find_in @data do |data, key|
-      keys << key.to_s
-      data_points << data
-    end
-
-    assert keys.empty?
-    assert data_points.empty?
-
-    matcher = Kronk::Path::Matcher.new :key       => "*",
-                                       :value     => "findme",
-                                       :recursive => true
-
-    paths = matcher.find_in @data do |data, key|
-      keys << key.to_s
-      data_points << data
-    end
-
-    assert_equal ['key1b'], keys
-    assert_equal [@data[:key1]], data_points
-    assert_equal ['key1b'], paths.first.matches
-  end
-
-
-  def test_find_in_match
-    matcher = Kronk::Path::Matcher.new :key       => "find*",
-                                       :value     => "th*g",
-                                       :recursive => true
-    paths = matcher.find_in @data
-    assert_equal [[:key1, :key1a, 3, :findme]], paths
-    assert_equal Kronk::Path::Match, paths.first.class
-
-    assert_equal ["me", "in"], paths.first.matches
-  end
-
-
-  def test_find_in_match_one
-    matcher = Kronk::Path::Matcher.new :key       => "findme|foo",
-                                       :recursive => true
-    paths = matcher.find_in @data
-
-    expected_paths = [
-      ["findme"],
-      ["findme", 2, :findme],
-      [:key1, :key1a, 3, :findme]
-    ]
-
-    assert_equal expected_paths, (expected_paths | paths)
-    assert_equal Kronk::Path::Match, paths.first.class
-
-    assert_equal ["findme"], paths.first.matches
-  end
-
-
-  def test_find_in_match_one_value
-    matcher = Kronk::Path::Matcher.new :key       => "findme|foo",
-                                       :value     => "th*g",
-                                       :recursive => true
-    paths = matcher.find_in @data
-    assert_equal [[:key1, :key1a, 3, :findme]], paths
-    assert_equal Kronk::Path::Match, paths.first.class
-
-    assert_equal ["findme", "in"], paths.first.matches
-  end
-
-
-  def test_find_in_match_any
-    matcher = Kronk::Path::Matcher.new :key => "*"
-    paths = matcher.find_in @data
-
-    expected_paths = [
-      ["findme"],
-      [:key1],
-      [:key2],
-      [:key3]
-    ]
-
-    paths.each do |path|
-      assert path.splat.empty?,
-        "Expected empty splat for #{path.inspect} but got #{path.splat.inspect}"
-    end
-
-    assert_equal expected_paths, (expected_paths | paths)
-    assert_equal Kronk::Path::Match, paths.first.class
-    assert_equal expected_paths, (expected_paths | paths.map{|p| p.matches})
-  end
-
-
-  def test_find_in_match_value_only
-    matcher = Kronk::Path::Matcher.new :value     => "th*g",
-                                       :recursive => true
-
-    paths = matcher.find_in @data
-
-    assert_equal [[:key1, :key1a, 3, :findme]], paths
-    assert_equal ["in"], paths.first.matches
-  end
-
-
-  def test_find_in_match_value_and_nil_key
-    matcher = Kronk::Path::Matcher.new :key       => nil,
-                                       :value     => "th*g",
-                                       :recursive => true
-
-    paths = matcher.find_in @data
-
-    assert_equal [[:key1, :key1a, 3, :findme]], paths
-    assert_equal ["in"], paths.first.matches
-  end
-
-
-  def test_find_in_match_value_and_empty_key
-    matcher = Kronk::Path::Matcher.new :key       => "",
-                                       :value     => "th*g",
-                                       :recursive => true
-
-    paths = matcher.find_in @data
-
-    assert_equal [[:key1, :key1a, 3, :findme]], paths
-    assert_equal ["in"], paths.first.matches
-  end
-
-
-  def test_find_in_match_value_and_nil_value
-    matcher = Kronk::Path::Matcher.new :key       => "*3a",
-                                       :value     => nil,
-                                       :recursive => true
-
-    paths = matcher.find_in @data
-
-    assert_equal [[:key3, :key3a]], paths
-    assert_equal ["key"], paths.first.matches
-  end
-
-
-  def test_find_in_match_value_and_empty_value
-    matcher = Kronk::Path::Matcher.new :key       => "*3a",
-                                       :value     => "",
-                                       :recursive => true
-
-    paths = matcher.find_in @data
-
-    assert_equal [[:key3, :key3a]], paths
-    assert_equal ["key"], paths.first.matches
-  end
-
-
-  def test_find_in_match_splat
-    matcher = Kronk::Path::Matcher.new :key       => "findme",
-                                       :recursive => true
-
-    matches = matcher.find_in @data
-
-    splat_i = matches.index [:key1, :key1a, 3, :findme]
-    assert_equal [:key1, :key1a, 3], matches[splat_i].splat[0][1]
-
-    splat_i = matches.index ["findme"]
-    assert_equal [], matches[splat_i].splat[0][1]
-
-    splat_i = matches.index ["findme", 2, :findme]
-    assert_equal ["findme", 2], matches[splat_i].splat[0][1]
-  end
-
-
-  def test_find_in_match_splat_value
-    matcher = Kronk::Path::Matcher.new :value     => "foobar",
-                                       :recursive => true
-
-    matches = matcher.find_in @data
-
-    assert(matches.any?{|m|
-      m == [:key1, :key1a, 2] && assert_equal([:key1, :key1a, 2], m.splat[0][1])
-      true
-    })
-
-    assert(matches.any?{|m|
-      m == [:key2] && assert_equal([:key2], m.splat[0][1])
-      true
-    })
-  end
-
-
-  def test_parse_node_range
-    assert_equal 1..4,   @matcher.parse_node("1..4")
-    assert_equal 1...4,  @matcher.parse_node("1...4")
-    assert_equal "1..4", @matcher.parse_node("\\1..4")
-    assert_equal "1..4", @matcher.parse_node("1\\..4")
-    assert_equal "1..4", @matcher.parse_node("1.\\.4")
-    assert_equal "1..4", @matcher.parse_node("1..\\4")
-    assert_equal "1..4", @matcher.parse_node("1..4\\")
-  end
-
-
-  def test_parse_node_index_length
-    assert_equal 2...6, @matcher.parse_node("2,4")
-    assert_equal "2,4", @matcher.parse_node("\\2,4")
-    assert_equal "2,4", @matcher.parse_node("2\\,4")
-    assert_equal "2,4", @matcher.parse_node("2,\\4")
-    assert_equal "2,4", @matcher.parse_node("2,4\\")
-  end
-
-
-  def test_parse_node_anyval
-    assert_equal Kronk::Path::Matcher::ANY_VALUE, @matcher.parse_node("*")
-    assert_equal Kronk::Path::Matcher::ANY_VALUE, @matcher.parse_node("")
-    assert_equal Kronk::Path::Matcher::ANY_VALUE, @matcher.parse_node("**?*?*?")
-    assert_equal Kronk::Path::Matcher::ANY_VALUE, @matcher.parse_node(nil)
-  end
-
-
-  def test_parse_node_regex
-    assert_equal(/\A(?:test(.*))\Z/,       @matcher.parse_node("test*"))
-    assert_equal(/\A(?:(.?)test(.*))\Z/,   @matcher.parse_node("?test*"))
-    assert_equal(/\A(?:\?test(.*))\Z/,     @matcher.parse_node("\\?test*"))
-    assert_equal(/\A(?:(.?)test\*(.*))\Z/, @matcher.parse_node("?test\\**"))
-    assert_equal(/\A(?:(.?)test(.*))\Z/,   @matcher.parse_node("?test*?**??"))
-    assert_equal(/\A(?:(.?)test(.?)(.?)(.*))\Z/,
-      @matcher.parse_node("?test??**??"))
-    assert_equal(/\A(?:a|b)\Z/,            @matcher.parse_node("a|b"))
-    assert_equal(/\A(?:a|b(c|d))\Z/,       @matcher.parse_node("a|b(c|d)"))
-
-    matcher = Kronk::Path::Matcher.new :regex_opts => Regexp::IGNORECASE
-    assert_equal(/\A(?:a|b(c|d))\Z/i, matcher.parse_node("a|b(c|d)"))
-  end
-
-
-  def test_parse_node_string
-    assert_equal "a|b", @matcher.parse_node("a\\|b")
-    assert_equal "a(b", @matcher.parse_node("a\\(b")
-    assert_equal "a?b", @matcher.parse_node("a\\?b")
-    assert_equal "a*b", @matcher.parse_node("a\\*b")
-  end
-
-
-  def test_parse_node_passthru
-    assert_equal Kronk::Path::PARENT,
-      @matcher.parse_node(Kronk::Path::PARENT)
-
-    assert_equal :thing, @matcher.parse_node(:thing)
-  end
-end

data/test/test_transaction.rb

@@ -1,520 +0,0 @@
-require 'test/test_helper'
-
-class TestTransaction < Test::Unit::TestCase
-
-  def setup
-    @data = {
-      :key1 => {
-        :key1a => [
-          "foo",
-          "bar",
-          "foobar",
-          {:findme => "thing"}
-        ],
-        'key1b' => "findme"
-      },
-      'findme' => [
-        123,
-        456,
-        {:findme => 123456}
-      ],
-      :key2 => "foobar",
-      :key3 => {
-        :key3a => ["val1", "val2", "val3"]
-      }
-    }
-
-    @trans = Kronk::Path::Transaction.new @data
-  end
-
-
-  def test_many_transactions
-    data = @trans.run do |t|
-      t.select "findme/0..1", "key(1|3)"
-      t.move [["key3/*/0", "key_value"], ["key?", "thing%1"]]
-      t.delete "findme/0"
-      t.move "findme/1" => "last_thing"
-    end
-
-    expected = {
-      "last_thing"=>456 , "key_value"=>"val1", "findme" => [],
-      "thing1"=>{:key1a=>["foo", "bar", "foobar", {:findme=>"thing"}],
-        "key1b"=>"findme"},
-      "thing3"=>{:key3a=>["val2", "val3"]}}
-
-    assert_equal expected, data
-  end
-
-
-  def test_many_transactions_with_map
-    data = @trans.run do |t|
-      t.select "findme/0..1", "key(1|3)"
-      t.map [["key3/*/0", "key_value"], ["key?", "thing%1"]]
-      t.delete "findme/0"
-      t.move "findme/1" => "last_thing"
-    end
-
-    expected = {
-      "key_value"=>"val1",
-      "thing1"=>{:key1a=>["foo", "bar", "foobar", {:findme=>"thing"}],
-        "key1b"=>"findme"},
-      "thing3"=>{:key3a=>["val2", "val3"]}}
-
-    assert_equal expected, data
-  end
-
-
-  def test_class_run
-    block = lambda do |t|
-      t.delete "key3/key*/2", "**=thing"
-      t.select "**=foo*", "**/findme"
-    end
-
-    assert_equal @trans.run(&block),
-      Kronk::Path::Transaction.run(@data, &block)
-
-    assert_equal @trans.run(:keep_indicies => true, &block),
-      Kronk::Path::Transaction.run(@data, :keep_indicies => true, &block)
-  end
-
-
-  def test_run
-    expected = {
-      :key1=>{:key1a=>["foo", "foobar"]},
-      :key2=>"foobar",
-      "findme"=>[123, 456, {:findme=>123456}]
-    }
-
-    result = @trans.run do |t|
-      t.delete "key3/key*/2", "**=thing"
-      t.select "**=foo*", "**/findme"
-    end
-
-    assert_equal expected, result
-    assert_equal @data, @trans.run
-
-    result2 = @trans.run do |t|
-      t.delete "key3/key*/2", "**=thing"
-      t.select "**=foo*", "**/findme"
-    end
-
-    assert_equal expected, result2
-  end
-
-
-  def test_results
-    @trans.clear
-    @trans.delete "key3/key*/2", "**=thing"
-    @trans.select "**=foo*", "**/findme"
-    result = @trans.results
-
-    expected = {
-      :key1=>{:key1a=>["foo", "foobar"]},
-      :key2=>"foobar",
-      "findme"=>[123, 456, {:findme=>123456}]
-    }
-
-    assert_equal expected, result
-  end
-
-
-  def test_results_keep_indicies
-    @trans.clear
-    @trans.delete "key3/key*/2", "**=thing"
-    @trans.select "**=foo*", "**/findme"
-    result = @trans.results :keep_indicies => true
-
-    expected = {
-      :key1=>{:key1a=>{2=>"foobar", 0=>"foo"}},
-      :key2=>"foobar",
-      "findme"=>[123, 456, {:findme=>123456}]
-    }
-
-    assert_equal expected, result
-  end
-
-
-  def test_remake_arrays_select
-    result = @trans.transaction_select @data, "**=foo", "key3/key*/2"
-    result = @trans.remake_arrays result
-
-    expected = {:key1=>{:key1a=>["foo"]}, :key3=>{:key3a=>["val3"]}}
-
-    assert_equal expected, result
-  end
-
-
-  def test_remake_arrays_select_except_modified
-    result = @trans.transaction_select @data, "**=foo", "key3/key*/2"
-    result = @trans.remake_arrays result, true
-
-    expected = {:key1=>{:key1a=>{0=>"foo"}}, :key3=>{:key3a=>{2=>"val3"}}}
-
-    assert_equal expected, result
-  end
-
-
-  def test_remake_arrays_select_root
-    data_arr = @data.keys.sort{|x,y| x.to_s <=> y.to_s}.map{|k| @data[k]}
-
-    @trans = Kronk::Path::Transaction.new data_arr
-    result = @trans.transaction_select data_arr, "**=foo", "3/key*/2"
-    result = @trans.remake_arrays result
-
-    expected = [{:key1a=>["foo"]}, {:key3a=>["val3"]}]
-
-    assert_equal expected, result
-  end
-
-
-  def test_remake_arrays_select_root_except_modified
-    data_arr = @data.keys.sort{|x,y| x.to_s <=> y.to_s}.map{|k| @data[k]}
-
-    @trans = Kronk::Path::Transaction.new data_arr
-    result = @trans.transaction_select data_arr, "**=foo", "3/key*"
-    result = @trans.remake_arrays result, true
-
-    expected = {1=>{:key1a=>{0=>"foo"}}, 3=>{:key3a=>["val1", "val2", "val3"]}}
-
-    assert_equal expected, result
-  end
-
-
-  def test_remake_arrays_delete
-    result = @trans.transaction_delete @data, "**=foo", "key3/key*/2"
-    result = @trans.remake_arrays result
-
-    expected = {
-      :key1 => {
-        :key1a => ["bar", "foobar", {:findme => "thing"}],
-        'key1b' => "findme"
-      },
-      'findme' => [123, 456, {:findme => 123456}],
-      :key2 => "foobar",
-      :key3 => {
-        :key3a => ["val1", "val2"]
-      }
-    }
-
-    assert_equal expected, result
-  end
-
-
-  def test_remake_arrays_delete_except_modified
-    result = @trans.transaction_delete @data, "**=foo", "key3/key*/2"
-    result = @trans.remake_arrays result, true
-
-    expected = {
-      :key1 => {
-        :key1a => {1=>"bar", 2=>"foobar", 3=>{:findme=>"thing"}},
-        'key1b' => "findme"
-      },
-      'findme' => [123, 456, {:findme => 123456}],
-      :key2 => "foobar",
-      :key3 => {
-        :key3a => {0=>"val1", 1=>"val2"}
-      }
-    }
-
-    assert_equal expected, result
-  end
-
-
-  def test_remake_arrays_delete_root
-    data_arr = @data.keys.sort{|x,y| x.to_s <=> y.to_s}.map{|k| @data[k]}
-
-    @trans = Kronk::Path::Transaction.new data_arr
-    result = @trans.transaction_delete data_arr, "**=foo", "3/key*/2"
-    result = @trans.remake_arrays result
-
-    expected = [
-      [123, 456, {:findme=>123456}],
-      {:key1a=>["bar", "foobar", {:findme=>"thing"}], "key1b"=>"findme"},
-      "foobar",
-      {:key3a=>["val1", "val2"]}
-    ]
-
-    assert_equal expected, result
-  end
-
-
-  def test_remake_arrays_delete_root_except_modified
-    data_arr = @data.keys.sort{|x,y| x.to_s <=> y.to_s}.map{|k| @data[k]}
-
-    @trans = Kronk::Path::Transaction.new data_arr
-    result = @trans.transaction_delete data_arr, "**=foo", "3/key*/2"
-    result = @trans.remake_arrays result, true
-
-    expected = [
-      [123, 456, {:findme=>123456}],
-      {:key1a=>{1=>"bar", 2=>"foobar", 3=>{:findme=>"thing"}},
-      "key1b"=>"findme"},
-      "foobar",
-      {:key3a=>{0=>"val1", 1=>"val2"}}
-    ]
-
-    assert_equal expected, result
-  end
-
-
-  def test_transaction_select
-    result = @trans.transaction_select @data, "**=foo", "key3/key*/2"
-    expected = {:key1=>{:key1a=>{0=>"foo"}}, :key3=>{:key3a=>{2=>"val3"}}}
-
-    assert_equal expected, result
-  end
-
-
-  def test_transaction_select_array
-    data_arr = @data.keys.sort{|x,y| x.to_s <=> y.to_s}.map{|k| @data[k]}
-
-    result = @trans.transaction_select data_arr, "**=foo", "3/key*/2"
-    expected = {1=>{:key1a=>{0=>"foo"}}, 3=>{:key3a=>{2=>"val3"}}}
-
-    assert_equal expected, result
-  end
-
-
-  def test_transaction_select_empty
-    assert_equal @data, @trans.transaction_select(@data)
-  end
-
-
-  def test_transaction_delete
-    result = @trans.transaction_delete @data, "**=foo", "key3/key*/2"
-    expected = {
-      :key1 => {
-        :key1a => {1 => "bar", 2 => "foobar", 3 => {:findme => "thing"}},
-        'key1b' => "findme"
-      },
-      'findme' => [123, 456, {:findme => 123456}],
-      :key2 => "foobar",
-      :key3 => {
-        :key3a => {0 => "val1", 1 => "val2"}
-      }
-    }
-
-    assert_equal expected, result
-  end
-
-
-  def test_transaction_delete_array
-    data_arr = @data.keys.sort{|x,y| x.to_s <=> y.to_s}.map{|k| @data[k]}
-
-    result = @trans.transaction_delete data_arr, "**=foo", "3/key*/2"
-    expected = {
-      0 => [123, 456, {:findme => 123456}],
-      1 => {
-        :key1a => {1 => "bar", 2 => "foobar", 3 => {:findme => "thing"}},
-        'key1b' => "findme"
-      },
-      2 => "foobar",
-      3 => {:key3a => {0 => "val1", 1 => "val2"}}
-    }
-
-    assert_equal expected, result
-  end
-
-
-  def test_transaction_delete_many_from_embedded_data
-    result = @trans.transaction_delete @data, "key1/key1a/1", "key1/key1a/0"
-    expected = {
-      :key1a => {2 => "foobar", 3 => {:findme => "thing"}},
-      'key1b' => "findme"
-      }
-
-    assert_equal expected, result[:key1]
-  end
-
-
-  def test_transaction_delete_empty
-    assert_equal @data, @trans.transaction_delete(@data)
-  end
-
-
-  def test_transaction_move
-    expected = {:key1=>{}, :key2=>"foobar",
-      "mapped"=>{
-        "1-a"=>["foo", "bar", "foobar", {}],
-        "1-b"=>"findme", "3-a"=>["val1", "val2", "val3"]},
-      :key3=>{}, "findme"=>[123, 456, {}],
-      "more"=>{"one-findme"=>"thing", "two-findme"=>123456}}
-
-    data = @trans.transaction_move @data,
-              ["**=thing",   "more/one-%1"],
-              ["key*/key??", "mapped/%1-%3"],
-              ["mapped",     "remapped"],
-              ["**=123456",  "more/two-%1"]
-    data = @trans.remake_arrays data
-
-    assert_equal expected, data
-    assert_not_equal @data, data
-  end
-
-
-  def test_transaction_map
-    expected = {
-      "mapped"=>{
-        "1-a"=>["foo", "bar", "foobar", {}],
-        "1-b"=>"findme", "3-a"=>["val1", "val2", "val3"]},
-      "more"=>[{:findme=>"thing"}]
-    }
-
-    data = @trans.transaction_map @data,
-              ["**=thing",   "more/12/%1"],
-              ["key*/key??", "mapped/%1-%3"],
-              ["mapped",     "remapped"]
-
-    data = @trans.remake_arrays data
-
-    assert_equal expected, data
-    assert_not_equal @data, data
-  end
-
-
-  def test_transaction_map_no_target
-    expected = {
-      "mapped"=>{
-        "1-a"=>["foo", "bar", "foobar", {}],
-        "1-b"=>"findme", "3-a"=>["val1", "val2", "val3"]},
-      :key1=>{:key1a => [{:findme=>"thing"}]}
-    }
-
-    data = @trans.transaction_map @data,
-              "**=thing",
-              ["key*/key??", "mapped/%1-%3"],
-              ["mapped",     "remapped"]
-
-    data = @trans.remake_arrays data
-
-    assert_equal expected, data
-    assert_not_equal @data, data
-  end
-
-
-  def test_transaction_move_array_conflicting
-    expected = {:key1=>{:key1a=>[], "key1b"=>"findme"},:key2=>"foobar",
-      :key3=>{:key3a=>[]}, "findme"=>[123, 456, {:findme=>123456}]}
-
-    data = @trans.transaction_move @data, ["key*/key??/*", "mapped/%4"]
-    data = @trans.remake_arrays data
-
-    mapped = data.delete "mapped"
-
-    assert_equal expected, data
-    assert_not_equal @data, data
-
-    assert_equal({:findme=>"thing"}, mapped.last)
-
-    # Due to unordered hashes, this could be
-    # %w{val1 val2 val3} OR %w{foo bar foobar}
-    assert_equal [String], mapped[0..2].map{|v| v.class}.uniq
-  end
-
-
-  def test_force_assign_paths
-    data = {'foo' => 'bar'}
-
-    new_data = @trans.force_assign_paths data,
-                 %w{sub thing one}   => 'val1',
-                 %w{sub thing two}   => 'val2',
-                 ['sub', 'other', 3] => 'val3',
-                 ['sub', 'other', 1] => 'val4',
-                 ['sub', 'other', 5, 6] => 'val5'
-
-    assert_equal({'foo' => 'bar'}, data)
-
-    expected = {
-      'foo' => 'bar',
-      'sub' => {
-        'thing' => {'one' => 'val1', 'two' => 'val2'},
-        'other' => {3 => 'val3', 1 => 'val4', 5 => {6 => 'val5'}}
-      }
-    }
-    assert_equal expected, new_data
-
-    expected['sub']['other'] = ['val4', 'val3', ['val5']]
-    new_data = @trans.remake_arrays new_data
-    assert_equal expected, new_data
-  end
-
-
-  def test_force_assign_paths_root_array
-    data = ['foo', 'bar']
-
-    new_data = @trans.force_assign_paths data,
-                 [1, 'thing', 'one'] => 'val1',
-                 [1, 'thing', 'two'] => 'val2',
-                 [3, 'other', 3]     => 'val3',
-                 [3, 'other', 1]     => 'val4',
-                 [3, 'other', 5, 6]  => 'val5'
-
-    assert_equal(['foo', 'bar'], data)
-
-    expected = {
-      0 => 'foo',
-      1 => {'thing' => {'one' => 'val1', 'two' => 'val2'}},
-      3 => {'other' => {3 => 'val3', 1 => 'val4', 5 => {6 => 'val5'}}}
-    }
-    assert_equal expected, new_data
-
-    expected[3]['other'] = ['val4', 'val3', ['val5']]
-    expected = @trans.hash_to_ary expected
-
-    new_data = @trans.remake_arrays new_data
-    assert_equal expected, new_data
-  end
-
-
-  def test_is_integer
-    assert @trans.is_integer?("123")
-    assert @trans.is_integer?(:"123")
-    assert !@trans.is_integer?("foo123")
-    assert !@trans.is_integer?(:foo123)
-  end
-
-
-  def test_ary_to_hash
-    expected = {1 => :a, 0 => :foo, 2 => :b}
-    assert_equal expected, @trans.ary_to_hash([:foo, :a, :b])
-  end
-
-
-  def test_hash_to_ary
-    assert_equal [:foo, :a, :b], @trans.hash_to_ary(1 => :a, 0 => :foo, 2 => :b)
-  end
-
-
-  def test_clear
-    @trans.delete "foo"
-    @trans.select "bar"
-
-    @trans.clear
-
-    assert @trans.instance_variable_get(:@actions).empty?
-    assert @trans.instance_variable_get(:@make_array).empty?
-  end
-
-
-  def test_select
-    @trans.select "path1", "path2", "path3"
-    assert_equal [[:select, ["path1", "path2", "path3"]]],
-                 @trans.instance_variable_get(:@actions)
-
-    @trans.select "path4", "path5"
-    assert_equal [[:select, ["path1", "path2", "path3", "path4", "path5"]]],
-                 @trans.instance_variable_get(:@actions)
-  end
-
-
-  def test_delete
-    @trans.delete "path1", "path2", "path3"
-    assert_equal [[:delete, ["path1", "path2", "path3"]]],
-                 @trans.instance_variable_get(:@actions)
-
-    @trans.delete "path4", "path5"
-    assert_equal [[:delete, ["path1", "path2", "path3"]],
-                  [:delete, ["path4", "path5"]]],
-                 @trans.instance_variable_get(:@actions)
-  end
-end