kronk 1.3.1 → 1.4.0

data/script/kronk_completion

@@ -8,10 +8,11 @@ _kronk()
 
   cur="${COMP_WORDS[COMP_CWORD]}"
 
-  kronk_keys="$HOME/.kronk_history"
+  kronk_keys="$HOME/.kronk/history"
+  test -f "$kronk_keys" || kronk_keys="$HOME/.kronk_history"
 
   if [ -f "$kronk_keys" ]; then
-    COMPREPLY=( $(compgen -W "$(cat $kronk_keys)" -- ${cur}) )
+    COMPREPLY=( $(compgen -W "$(cat $kronk_keys $old_kronk_keys)" -- ${cur}) )
     return 0
   fi
 

data/test/test_core_ext.rb

@@ -12,14 +12,14 @@ class TestCoreExt < Test::Unit::TestCase
   def test_has_path_array
     assert @array.has_path?("**/foo")
     assert @array.has_path?("**/foo=other")
-    assert_nil @array.has_path?("**/foobar")
+    assert !@array.has_path?("**/foobar")
   end
 
 
   def test_has_path_hash
     assert @hash.has_path?("**/foo")
     assert @hash.has_path?("**/foo=other")
-    assert_nil @hash.has_path?("**/foobar")
+    assert !@hash.has_path?("**/foobar")
   end
 
 

data/test/test_data_set.rb

@@ -2,7 +2,6 @@ require 'test/test_helper'
 
 class TestDataSet < Test::Unit::TestCase
 
-
   def setup
     @data = {
       :key1 => {
@@ -28,6 +27,8 @@ class TestDataSet < Test::Unit::TestCase
     @dataset = Kronk::DataSet.new @data
 
     @dataset_mock = Kronk::DataSet.new mock_data
+
+    Kronk::Cmd.expects :warn
   end
 
 
@@ -48,12 +49,14 @@ class TestDataSet < Test::Unit::TestCase
 
 
   def test_modify_only_data_with
+    Kronk::Cmd.expects :warn
     data = @dataset_mock.modify :only_data_with => "subs/1"
     assert_equal({"subs" => ["a", "b"]}, data)
   end
 
 
   def test_modify_only_and_ignored_data
+    Kronk::Cmd.expects :warn
     data = @dataset_mock.modify :ignore_data => "subs/1", :only_data => "subs/1"
     assert_equal({"subs" => [nil]}, data)
   end
@@ -207,300 +210,4 @@ class TestDataSet < Test::Unit::TestCase
 
     assert_equal expected, data
   end
-
-
-  def test_find_data_index
-    keys = []
-    data_points = []
-
-    @dataset.find_data "*/*/0|1" do |data, key, path|
-      keys << key
-      data_points << data
-    end
-
-    assert_equal [0,1,0,1], keys
-    assert_equal 2, data_points.count(@data[:key1][:key1a])
-    assert_equal 2, data_points.count(@data[:key3][:key3a])
-  end
-
-
-  def test_find_data_recursive_wildcard_value
-    keys = []
-    paths = []
-    data_points = []
-
-    @dataset.find_data "**=foo*" do |data, key, path|
-      keys << key
-      data_points << data
-      paths << path
-    end
-
-    expected_paths = [[:key1,:key1a,0], [:key1,:key1a,2], [:key2]]
-
-    assert_equal [0,2,:key2], ([0,2,:key2] | keys)
-    assert_equal expected_paths, (expected_paths | paths)
-  end
-
-
-  def test_find_data_recursive
-    keys = []
-    paths = []
-    data_points = []
-
-    @dataset.find_data "**/findme" do |data, key, path|
-      keys << key.to_s
-      data_points << data
-      paths << path
-    end
-
-    expected_paths =
-      [[:key1,:key1a,3,:findme], ["findme"], ["findme",2,:findme]]
-
-    assert_equal 3, keys.length
-    assert_equal 1, keys.uniq.length
-    assert_equal "findme", keys.first
-
-    assert data_points.include?(@data)
-    assert data_points.include?(@data[:key1][:key1a].last)
-    assert data_points.include?(@data['findme'].last)
-
-    assert_equal expected_paths, (expected_paths | paths)
-  end
-
-
-  def test_find_data_wildcard
-    keys = []
-    data_points = []
-
-    @dataset.find_data "*/key1?" do |data, key, path|
-      keys << key.to_s
-      data_points << data
-    end
-
-    assert_equal ['key1a', 'key1b'], keys.sort
-    assert_equal [@data[:key1], @data[:key1]], data_points
-  end
-
-
-  def test_parse_data_path
-    data_path = "key1/key\\/2=value/key*=*value/**=value2/key\\=thing"
-    key, value, rec, data_path = @dataset.parse_data_path data_path
-
-    assert_equal "key1", key
-    assert_nil value
-    assert !rec, "Should not return recursive = true"
-    assert_equal "key\\/2=value/key*=*value/**=value2/key\\=thing", data_path
-  end
-
-
-  def test_parse_data_path_escaped_slash
-    key, value, rec, data_path =
-      @dataset.parse_data_path \
-        "key\\/2=value/key*=*value/**=value2/key\\=thing"
-
-    assert_equal "key/2", key
-    assert_equal "value", value
-    assert !rec, "Should not return recursive = true"
-    assert_equal "key*=*value/**=value2/key\\=thing", data_path
-  end
-
-
-  def test_parse_data_path_wildcard
-    key, value, rec, data_path = @dataset.parse_data_path "*/key1?"
-
-    assert_equal(/^(.*)$/i, key)
-    assert_nil value
-    assert !rec, "Should not return recursive = true"
-    assert_equal "key1?", data_path
-  end
-
-
-  def test_parse_data_path_recursive_value
-    key, value, rec, data_path =
-      @dataset.parse_data_path "**=value2/key\\=thing"
-
-    assert_equal(/.*/, key)
-    assert_equal "value2", value
-    assert rec, "Should return recursive = true"
-    assert_equal "key\\=thing", data_path
-  end
-
-
-  def test_parse_data_path_recursive
-    data_path = "**"
-    key, value, rec, data_path = @dataset.parse_data_path "**"
-
-    assert_equal(/.*/, key)
-    assert_nil value
-    assert rec, "Should return recursive = true"
-    assert_nil data_path
-  end
-
-
-  def test_parse_data_path_recursive_key
-    data_path = "**"
-    key, value, rec, data_path = @dataset.parse_data_path "**/key"
-
-    assert_equal "key", key
-    assert_nil value
-    assert rec, "Should return recursive = true"
-    assert_nil data_path
-  end
-
-
-  def test_parse_data_path_escaped_equal
-    key, value, rec, data_path = @dataset.parse_data_path "key\\=thing"
-
-    assert_equal "key=thing", key
-    assert_nil value
-    assert !rec, "Should not return recursive = true"
-    assert_equal nil, data_path
-  end
-
-
-  def test_parse_data_path_last
-    key, value, rec, data_path = @dataset.parse_data_path "key*"
-
-    assert_equal(/^(key.*)$/i, key)
-    assert_nil value
-    assert !rec, "Should not return recursive = true"
-    assert_equal nil, data_path
-  end
-
-
-  def test_parse_data_path_empty
-    key, value, rec, data_path = @dataset.parse_data_path ""
-
-    assert_equal nil, key
-    assert_nil value
-    assert !rec, "Should not return recursive = true"
-    assert_equal nil, data_path
-  end
-
-
-  def test_parse_path_item
-    assert_equal "foo", @dataset.parse_path_item("foo")
-
-    assert_equal(/^(foo.*bar)$/i, @dataset.parse_path_item("foo*bar"))
-    assert_equal(/^(foo|bar)$/i, @dataset.parse_path_item("foo|bar"))
-    assert_equal(/^(foo.?bar)$/i, @dataset.parse_path_item("foo?bar"))
-
-    assert_equal(/^(foo.?\?bar)$/i, @dataset.parse_path_item("foo?\\?bar"))
-    assert_equal(/^(key.*)$/i, @dataset.parse_path_item("key*"))
-
-    assert_equal "foo*bar", @dataset.parse_path_item("foo\\*bar")
-    assert_equal "foo|bar", @dataset.parse_path_item("foo\\|bar")
-    assert_equal "foo?bar", @dataset.parse_path_item("foo\\?bar")
-
-    assert_equal 1..3, @dataset.parse_path_item("1..3")
-    assert_equal 1...3, @dataset.parse_path_item("1...3")
-    assert_equal 3...6, @dataset.parse_path_item("3,3")
-  end
-
-
-  def test_yield_data_points
-    keys = []
-
-    @dataset.yield_data_points @data, /key/ do |data, key|
-      keys << key.to_s
-      assert_equal @data, data
-    end
-
-    assert_equal ['key1', 'key2', 'key3'], keys.sort
-  end
-
-
-  def test_yield_data_points_recursive
-    keys = []
-    data_points = []
-
-    @dataset.yield_data_points @data, :findme, nil, true do |data, key|
-      keys << key.to_s
-      data_points << data
-    end
-
-    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_yield_data_points_value
-    keys = []
-    data_points = []
-
-    @dataset.yield_data_points @data, nil, "findme" do |data, key|
-      keys << key.to_s
-      data_points << data
-    end
-
-    assert keys.empty?
-    assert data_points.empty?
-
-    @dataset.yield_data_points @data, nil, "findme", true do |data, key|
-      keys << key.to_s
-      data_points << data
-    end
-
-    assert_equal ['key1b'], keys
-    assert_equal [@data[:key1]], data_points
-  end
-
-
-  def test_match_data_item
-    assert @dataset.match_data_item(:key, "key")
-    assert @dataset.match_data_item("key", :key)
-
-    assert @dataset.match_data_item(/key/, "foo_key")
-    assert !@dataset.match_data_item("foo_key", /key/)
-    assert @dataset.match_data_item(/key/, /key/)
-
-    assert @dataset.match_data_item(nil, "foo_key")
-    assert !@dataset.match_data_item("foo_key", nil)
-
-    assert @dataset.match_data_item(1..3, 1)
-    assert !@dataset.match_data_item(1, 1..3)
-    assert @dataset.match_data_item(1..3, 1..3)
-  end
-
-
-  def test_hash_each_data_item
-    hash = {
-      :a => 1,
-      :b => 2,
-      :c => 3
-    }
-
-    keys = []
-    values = []
-
-    @dataset.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_array_each_data_item
-    ary = [:a, :b, :c]
-
-    keys = []
-    values = []
-
-    @dataset.each_data_item ary do |key, val|
-      keys << key
-      values << val
-    end
-
-    assert_equal [0,1,2], keys
-    assert_equal ary, values
-  end
 end

data/test/test_diff.rb

@@ -75,16 +75,16 @@ class TestDiff < Test::Unit::TestCase
    ]
   ],
  {
+  :tests => [
+   "D3a",
+   "D3b"
+   ],
   "test" => [
    [
     "D1a\\nContent goes here",
     "D1b"
     ],
    "D2"
-   ],
-  :tests => [
-   "D3a",
-   "D3b"
    ]
   }
  ],
@@ -93,14 +93,14 @@ class TestDiff < Test::Unit::TestCase
  "b"
  ],
 "tests" => {
+ :foo => :bar,
  "test" => [
   [
    1,
    2
    ],
   2.123
-  ],
- :foo => :bar
+  ]
  }
 }
 STR
@@ -140,16 +140,16 @@ STR
    ]
   ],
  {
+  :tests => [
+   String,
+   String
+   ],
   "test" => [
    [
     String,
     String
     ],
    String
-   ],
-  :tests => [
-   String,
-   String
    ]
   }
  ],
@@ -158,14 +158,14 @@ STR
  String
  ],
 "tests" => {
+ :foo => Symbol,
  "test" => [
   [
    Fixnum,
    Fixnum
    ],
   Float
-  ],
- :foo => Symbol
+  ]
  }
 }
 STR

data/test/test_kronk.rb

@@ -486,6 +486,8 @@ STR
     options = {}
     argv = %w{this is --argv -- one -two -- -three four :parents :-not_parents}
 
+    Kronk::Cmd.expects(:warn).times(2)
+
     options = Kronk::Cmd.parse_data_path_args options, argv
 
     assert_equal %w{one four}, options[:only_data]

data/test/test_path.rb

@@ -0,0 +1,370 @@
+require 'test/test_helper'
+
+class TestPath < 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"]
+      }
+    }
+  end
+
+
+  def test_each_data_item_hash
+    hash = {
+      :a => 1,
+      :b => 2,
+      :c => 3
+    }
+
+    keys = []
+    values = []
+
+    Kronk::Path.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 = []
+
+    Kronk::Path.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_data_item
+    assert Kronk::Path.match_data_item(:key, "key")
+    assert Kronk::Path.match_data_item("key", :key)
+
+    assert Kronk::Path.match_data_item(/key/, "foo_key")
+    assert !Kronk::Path.match_data_item("foo_key", /key/)
+    assert Kronk::Path.match_data_item(/key/, /key/)
+
+    assert Kronk::Path.match_data_item(Kronk::Path::ANY_VALUE, "foo_key")
+    assert !Kronk::Path.match_data_item("foo_key", Kronk::Path::ANY_VALUE)
+
+    assert Kronk::Path.match_data_item(1..3, 1)
+    assert !Kronk::Path.match_data_item(1, 1..3)
+    assert Kronk::Path.match_data_item(1..3, 1..3)
+  end
+
+
+  def test_find_match
+    keys = []
+
+    Kronk::Path.find_match @data, /key/ do |data, key|
+      keys << key.to_s
+      assert_equal @data, data
+    end
+
+    assert_equal ['key1', 'key2', 'key3'], keys.sort
+  end
+
+
+  def test_find_match_recursive
+    keys = []
+    data_points = []
+
+    Kronk::Path.find_match @data, :findme, ANY_VALUE, true do |data, key|
+      keys << key.to_s
+      data_points << data
+    end
+
+    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_match_value
+    keys = []
+    data_points = []
+
+    Kronk::Path.find_match @data, ANY_VALUE, "findme" do |data, key|
+      keys << key.to_s
+      data_points << data
+    end
+
+    assert keys.empty?
+    assert data_points.empty?
+
+    Kronk::Path.find_match @data, ANY_VALUE, "findme", true do |data, key|
+      keys << key.to_s
+      data_points << data
+    end
+
+    assert_equal ['key1b'], keys
+    assert_equal [@data[:key1]], data_points
+  end
+
+
+  def test_find_wildcard
+    keys = []
+    data_points = []
+
+    Kronk::Path.find "*/key1?", @data do |data, key, path|
+      keys << key.to_s
+      data_points << data
+    end
+
+    assert_equal ['key1a', 'key1b'], keys.sort
+    assert_equal [@data[:key1], @data[:key1]], data_points
+  end
+
+
+  def test_find_recursive
+    keys = []
+    paths = []
+    data_points = []
+
+    Kronk::Path.find "**/findme", @data do |data, key, path|
+      keys << key.to_s
+      data_points << data
+      paths << path
+    end
+
+    expected_paths =
+      [[:key1,:key1a,3,:findme], ["findme"], ["findme",2,:findme]]
+
+    assert_equal 3, keys.length
+    assert_equal 1, keys.uniq.length
+    assert_equal "findme", keys.first
+
+    assert data_points.include?(@data)
+    assert data_points.include?(@data[:key1][:key1a].last)
+    assert data_points.include?(@data['findme'].last)
+
+    assert_equal expected_paths, (expected_paths | paths)
+  end
+
+
+  def test_find_index
+    keys = []
+    data_points = []
+
+    Kronk::Path.find "*/*/0|1", @data do |data, key, path|
+      keys << key
+      data_points << data
+    end
+
+    assert_equal [1,0,1,0], keys
+    assert_equal 2, data_points.count(@data[:key1][:key1a])
+    assert_equal 2, data_points.count(@data[:key3][:key3a])
+  end
+
+
+  def test_find_data_recursive_wildcard_value
+    keys = []
+    paths = []
+    data_points = []
+
+    Kronk::Path.find "**=foo*", @data do |data, key, path|
+      keys << key
+      data_points << data
+      paths << path
+    end
+
+    expected_paths = [[:key1,:key1a,0], [:key1,:key1a,2], [:key2]]
+
+    assert_equal [0,2,:key2], ([0,2,:key2] | keys)
+    assert_equal expected_paths, (expected_paths | paths)
+  end
+
+
+  def test_parse_path_item_range
+    assert_equal 1..4,   Kronk::Path.parse_path_item("1..4")
+    assert_equal 1...4,  Kronk::Path.parse_path_item("1...4")
+    assert_equal "1..4", Kronk::Path.parse_path_item("\\1..4")
+    assert_equal "1..4", Kronk::Path.parse_path_item("1\\..4")
+    assert_equal "1..4", Kronk::Path.parse_path_item("1.\\.4")
+    assert_equal "1..4", Kronk::Path.parse_path_item("1..\\4")
+    assert_equal "1..4", Kronk::Path.parse_path_item("1..4\\")
+  end
+
+
+  def test_parse_path_item_index_length
+    assert_equal 2...6, Kronk::Path.parse_path_item("2,4")
+    assert_equal "2,4", Kronk::Path.parse_path_item("\\2,4")
+    assert_equal "2,4", Kronk::Path.parse_path_item("2\\,4")
+    assert_equal "2,4", Kronk::Path.parse_path_item("2,\\4")
+    assert_equal "2,4", Kronk::Path.parse_path_item("2,4\\")
+  end
+
+
+  def test_parse_path_item_anyval
+    assert_equal Kronk::Path::ANY_VALUE, Kronk::Path.parse_path_item("*")
+    assert_equal Kronk::Path::ANY_VALUE, Kronk::Path.parse_path_item("")
+    assert_equal Kronk::Path::ANY_VALUE, Kronk::Path.parse_path_item("**?*?*?")
+    assert_equal Kronk::Path::ANY_VALUE, Kronk::Path.parse_path_item(nil)
+  end
+
+
+  def test_parse_path_item_regex
+    assert_equal(/\A(test.*)\Z/,     Kronk::Path.parse_path_item("test*"))
+    assert_equal(/\A(.?test.*)\Z/,   Kronk::Path.parse_path_item("?test*"))
+    assert_equal(/\A(\?test.*)\Z/,   Kronk::Path.parse_path_item("\\?test*"))
+    assert_equal(/\A(.?test\*.*)\Z/, Kronk::Path.parse_path_item("?test\\**"))
+    assert_equal(/\A(.?test.*)\Z/,   Kronk::Path.parse_path_item("?test*?**??"))
+    assert_equal(/\A(a|b)\Z/,        Kronk::Path.parse_path_item("a|b"))
+    assert_equal(/\A(a|b(c|d))\Z/,   Kronk::Path.parse_path_item("a|b(c|d)"))
+
+    assert_equal(/\A(a|b(c|d))\Z/i,
+      Kronk::Path.parse_path_item("a|b(c|d)", Regexp::IGNORECASE))
+  end
+
+
+  def test_parse_path_item_string
+    assert_equal "a|b", Kronk::Path.parse_path_item("a\\|b")
+    assert_equal "a(b", Kronk::Path.parse_path_item("a\\(b")
+    assert_equal "a?b", Kronk::Path.parse_path_item("a\\?b")
+    assert_equal "a*b", Kronk::Path.parse_path_item("a\\*b")
+  end
+
+
+  def test_parse_path_item_passthru
+    assert_equal Kronk::Path::PARENT,
+      Kronk::Path.parse_path_item(Kronk::Path::PARENT)
+
+    assert_equal :thing, Kronk::Path.parse_path_item(:thing)
+  end
+
+
+  def test_parse_path_str_yield
+    all_args = []
+
+    Kronk::Path.parse_path_str "path/**/to=foo/item" do |*args|
+      all_args << args
+    end
+
+    expected = [
+      ["path", ANY_VALUE, false, false],
+      ["to", "foo", true, false],
+      ["item", ANY_VALUE, false, true],
+    ]
+
+    assert_equal expected, all_args
+  end
+
+
+  def test_parse_path_str_simple
+    assert_path %w{path to item}, "path/to/item"
+    assert_path %w{path to item}, "///path//to/././item///"
+    assert_path %w{path to item}, "///path//to/./item///"
+    assert_path %w{path/to item}, "path\\/to/item"
+
+    assert_path %w{path/to item/ i}, "path\\/to/item\\//i"
+
+    assert_path [/\A(path\/\.to)\Z/i, /\A(item)\Z/i],
+       "path\\/.to/item", Regexp::IGNORECASE
+
+    assert_path ['path', /\A(to|for)\Z/, 'item'], "path/to|for/item"
+  end
+
+
+  def test_parse_path_str_value
+    assert_path ['path', ['to', 'foo'], 'item'], "path/to=foo/item"
+    assert_path ['path', [nil, 'foo'], 'item'],  "path/*=foo/item"
+    assert_path ['path', [nil, 'foo'], 'item'],  "path/=foo/item"
+
+    assert_path ['path', ['to', /\A(foo|bar)\Z/], 'item'],
+      "path/to=foo|bar/item"
+
+    assert_path [/\A(path)\Z/i, [/\A(to)\Z/i, /\A(foo)\Z/i], /\A(item)\Z/i],
+      "path/to=foo/item", Regexp::IGNORECASE
+  end
+
+
+  def test_parse_path_str_recur
+    assert_path ['path', ['to', 'foo', true], 'item'],    "path/**/to=foo/item"
+    assert_path [['path', nil, true], 'to', 'item'],      "**/**/path/to/item"
+    assert_path ['path', 'to', 'item', [nil, nil, true]], "path/to/item/**/**"
+    assert_path ['path', [nil, 'foo', true], 'item'],     "path/**=foo/item"
+  end
+
+
+  def test_parse_path_str_parent
+    assert_path ['path', PARENT, 'item'],              "path/../item"
+    assert_path ['path', [PARENT, 'foo'], 'item'],     "path/..=foo/item"
+    assert_path ['path', [nil, 'foo', true], 'item'],  "path/**/..=foo/item"
+    assert_path ['path', [nil, 'foo', true], 'item'],  "path/**/=foo/item"
+    assert_path ['path', ['item', nil, true]],         "path/**/../item"
+    assert_path ['path', PARENT, ['item', nil, true]], "path/../**/item"
+  end
+
+
+  def test_parse_regex_opts
+    path = "path/to/item///mix"
+    opts = Kronk::Path.parse_regex_opts! path
+
+    assert_equal "path/to/item/", path
+
+    expected_opts = Regexp::IGNORECASE | Regexp::EXTENDED | Regexp::MULTILINE
+    assert_equal expected_opts, opts
+  end
+
+
+  def test_parse_regex_opts_mix
+    opts = Kronk::Path.parse_regex_opts! "path/to/item//m", Regexp::EXTENDED
+    assert_equal Regexp::EXTENDED | Regexp::MULTILINE, opts
+  end
+
+
+  def test_parse_regex_opts_none
+    assert_nil Kronk::Path.parse_regex_opts!("path/to/item//")
+    assert_equal Regexp::EXTENDED,
+      Kronk::Path.parse_regex_opts!("path/to/item//", Regexp::EXTENDED)
+  end
+
+
+  private
+
+  PARENT    = Kronk::Path::PARENT
+  ANY_VALUE = Kronk::Path::ANY_VALUE
+
+  def assert_path match, path, regexp_opt=nil
+    match.map! do |i|
+      i = [i] unless Array === i
+      i[0] ||= ANY_VALUE
+      i[1] ||= ANY_VALUE
+      i[2] ||= false
+      i
+    end
+
+    assert_equal match, Kronk::Path.parse_path_str(path, regexp_opt)
+  end
+end