kronk 1.8.5 → 1.8.6

data/test/test_core_ext.rb

@@ -1,74 +0,0 @@
-require 'test/test_helper'
-require 'lib/kronk/core_ext'
-
-class TestCoreExt < Test::Unit::TestCase
-
-  def setup
-    @array = [:a, :b, {:foo => "bar", :bar => [:a, :b, {:foo => "other"}]}, :c]
-    @hash  = {:foo => "bar", :bar => [:a, :b, {:foo => "other"}], :a => [1,2,3]}
-  end
-
-
-  def test_has_path_array
-    assert @array.has_path?("**/foo")
-    assert @array.has_path?("**/foo=other")
-    assert !@array.has_path?("**/foobar")
-  end
-
-
-  def test_has_path_hash
-    assert @hash.has_path?("**/foo")
-    assert @hash.has_path?("**/foo=other")
-    assert !@hash.has_path?("**/foobar")
-  end
-
-
-  def test_find_data_array
-    out = @array.find_data "**/foo"
-    assert_equal({[2, :foo] => "bar", [2, :bar, 2, :foo] => "other"}, out)
-  end
-
-
-  def test_find_data_array_empty
-    out = @array.find_data "**/foobar"
-    assert_equal({}, out)
-  end
-
-
-  def test_find_data_array_block
-    collected = []
-
-    @array.find_data "**/foo" do |data, key, path|
-      collected << [data, key, path]
-    end
-
-    assert_equal 2, collected.length
-    assert collected.include?([@array[2], :foo, [2, :foo]])
-    assert collected.include?([@array[2][:bar][2], :foo, [2, :bar, 2, :foo]])
-  end
-
-
-  def test_find_data_hash
-    out = @hash.find_data "**/foo"
-    assert_equal({[:foo] => "bar", [:bar, 2, :foo] => "other"}, out)
-  end
-
-
-  def test_find_data_hash_empty
-    out = @hash.find_data "**/foobar"
-    assert_equal({}, out)
-  end
-
-
-  def test_find_data_hash_block
-    collected = []
-
-    @hash.find_data "**/foo" do |data, key, path|
-      collected << [data, key, path]
-    end
-
-    assert_equal 2, collected.length
-    assert collected.include?([@hash, :foo, [:foo]])
-    assert collected.include?([@hash[:bar][2], :foo, [:bar, 2, :foo]])
-  end
-end

data/test/test_path.rb

@@ -1,317 +0,0 @@
-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_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)
-
-    splat_path = paths.find{|pa| pa[0] == :key1}
-    assert_equal [:key1, :key1a, 3], splat_path.splat[0][1]
-  end
-
-
-  def test_find_recursive_many_splat
-    path_match = nil
-
-    Kronk::Path.find "**/key1a/**=thing", @data do |data, key, path|
-      path_match = path
-    end
-
-    assert path_match
-    assert_equal [:key1], path_match.splat[0][1]
-    assert_equal [3], path_match.splat[1][1]
-  end
-
-
-  def test_find_recursive_many_splat_end_match
-    path_match = nil
-
-    Kronk::Path.find "**/key1a/**/*=thing", @data do |data, key, path|
-      path_match = path
-    end
-
-    assert path_match
-    assert_equal [:key1], path_match.splat[0][1]
-    assert_equal [3], path_match.splat[1][1]
-  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_pathed
-    expected = {
-      "/findme/0"            => 123,
-      "/findme/1"            => 456,
-      "/findme/2/findme"     => 123456,
-      "/key1/key1a/0"        => "foo",
-      "/key1/key1a/1"        => "bar",
-      "/key1/key1a/2"        => "foobar",
-      "/key1/key1a/3/findme" => "thing",
-      "/key1/key1b"          => "findme",
-      "/key2"                => "foobar",
-      "/key3/key3a/0"        => "val1",
-      "/key3/key3a/1"        => "val2",
-      "/key3/key3a/2"        => "val3"
-    }
-    assert_equal expected, Kronk::Path.pathed(@data)
-  end
-
-
-  def test_pathed_esc
-    @data['findme'][2]['*thing?'] = {
-      ".." => "parent",
-      "**" => "recurse",
-      "(hi|hey)" => "paren",
-      "more/here" => "path"
-    }
-
-    expected = {
-      "/findme/0"            => 123,
-      "/findme/1"            => 456,
-      "/findme/2/findme"     => 123456,
-
-      "/findme/2/\\*thing\\?/\\.\\."         => "parent",
-      "/findme/2/\\*thing\\?/\\*\\*"         => "recurse",
-      "/findme/2/\\*thing\\?/\\(hi\\|hey\\)" => "paren",
-      "/findme/2/\\*thing\\?/more\\/here"    => "path",
-
-      "/key1/key1a/0"        => "foo",
-      "/key1/key1a/1"        => "bar",
-      "/key1/key1a/2"        => "foobar",
-      "/key1/key1a/3/findme" => "thing",
-      "/key1/key1b"          => "findme",
-      "/key2"                => "foobar",
-      "/key3/key3a/0"        => "val1",
-      "/key3/key3a/1"        => "val2",
-      "/key3/key3a/2"        => "val3"
-    }
-    assert_equal expected, Kronk::Path.pathed(@data)
-  end
-
-
-  def test_pathed_not_esc
-    @data['findme'][2]['*thing?'] = {
-      ".." => "parent",
-      "**" => "recurse",
-      "(hi|hey)" => "paren",
-      "more/here" => "path"
-    }
-
-    expected = {
-      "/findme/0"            => 123,
-      "/findme/1"            => 456,
-      "/findme/2/findme"     => 123456,
-
-      "/findme/2/*thing?/.."        => "parent",
-      "/findme/2/*thing?/**"        => "recurse",
-      "/findme/2/*thing?/(hi|hey)"  => "paren",
-      "/findme/2/*thing?/more/here" => "path",
-
-      "/key1/key1a/0"        => "foo",
-      "/key1/key1a/1"        => "bar",
-      "/key1/key1a/2"        => "foobar",
-      "/key1/key1a/3/findme" => "thing",
-      "/key1/key1b"          => "findme",
-      "/key2"                => "foobar",
-      "/key3/key3a/0"        => "val1",
-      "/key3/key3a/1"        => "val2",
-      "/key3/key3a/2"        => "val3"
-    }
-    assert_equal expected, Kronk::Path.pathed(@data, false)
-  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 = [
-      [Kronk::Path::Matcher.new(:key => "path"), false],
-      [Kronk::Path::Matcher.new(:key => "to", :value => "foo",
-        :recursive => true), false],
-      [Kronk::Path::Matcher.new(:key => "item"), 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', ["*", '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, true]], "path/to/item/**/**"
-    assert_path ['path', ["*", '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', ["*", '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::Matcher::ANY_VALUE
-
-  def assert_path match, path, regexp_opt=nil
-    match.map! do |i|
-      i = [i] unless Array === i
-      Kronk::Path::Matcher.new :key => i[0], :value => i[1],
-        :recursive => i[2], :regex_opts => regexp_opt
-    end
-
-    assert_equal match, Kronk::Path.parse_path_str(path, regexp_opt)
-  end
-end

data/test/test_path_match.rb

@@ -1,105 +0,0 @@
-require 'test/test_helper'
-
-class TestPathMatch < Test::Unit::TestCase
-
-  def setup
-    @pmatch = Kronk::Path::Match.new %w{path to resource}
-    @pmatch.matches = %w{this is 4 foo}
-
-    @splat = @pmatch.dup
-    @splat.append_splat "first", "path"
-    @splat.append_splat "first", "to"
-    @splat.append_splat "second", "resource"
-    @splat.append_splat "second", "bar"
-  end
-
-
-  def test_new
-    assert_equal %w{this is 4 foo},    @pmatch.matches
-    assert_equal %w{path to resource}, @pmatch
-  end
-
-
-  def test_dup
-    new_match = @pmatch.dup
-    assert_equal new_match, @pmatch
-    assert_not_equal @pmatch.matches.object_id, new_match.matches.object_id
-    assert_equal %w{this is 4 foo}, @pmatch.matches
-    assert_equal %w{this is 4 foo}, new_match.matches
-  end
-
-
-  def test_make_path
-    path = @pmatch.make_path "/%3/2/path/%4_%1"
-    assert_equal %w{4 2 path foo_this}, path
-  end
-
-
-  def test_make_path_consecutive
-    path = @pmatch.make_path "/%3%4/2/path/%1"
-    assert_equal %w{4foo 2 path this}, path
-  end
-
-
-  def test_make_path_no_splat
-    path = @pmatch.make_path "/%%3/2/path/%4_%1"
-    assert_equal %w{3 2 path foo_this}, path
-  end
-
-
-  def test_make_path_consecutive_no_splat
-    path = @pmatch.make_path "/%%%4/2/path/%1"
-    assert_equal %w{foo 2 path this}, path
-
-    path = @pmatch.make_path "/%4%%/2/path/%1"
-    assert_equal %w{foo 2 path this}, path
-  end
-
-
-  def test_make_path_escape
-    path = @pmatch.make_path "/\\%3/2\\/path/%4_%1"
-    assert_equal %w{%3 2/path foo_this}, path
-
-    path = @pmatch.make_path "/\\\\%3/2/path/%4_%1/bar"
-    assert_equal %w{\4 2 path foo_this bar}, path
-  end
-
-
-  def test_make_path_escape_token_num
-    path = @pmatch.make_path "/%3\\1/2/path/%4_%1"
-    assert_equal %w{41 2 path foo_this}, path
-
-    path = @pmatch.make_path "/%\\31/2/path/%4_%1"
-    assert_equal %w{31 2 path foo_this}, path
-  end
-
-
-  def test_make_path_bad_token_num
-    path = @pmatch.make_path "/%31/2/path/%4_%1"
-    assert_equal ["", "2", "path", "foo_this"], path
-  end
-
-
-  def test_make_path_splat
-    path = @splat.make_path "/%4%%/2/thing"
-    assert_equal ["foopath", "to", "2", "thing"], path
-
-    path = @splat.make_path "/%4/%%/2/thing"
-    assert_equal ["foo", "path", "to", "2", "thing"], path
-
-    path = @splat.make_path "/%4/bah%%2/thing"
-    assert_equal ["foo", "bahpath", "to2", "thing"], path
-  end
-
-
-  def test_make_path_splat_multiple
-    path = @splat.make_path "/%4%%%%/2/thing"
-    assert_equal ["foopath", "toresource", "bar", "2", "thing"], path
-
-    path = @splat.make_path "/%4/%%/2/thing/%%"
-    assert_equal ["foo", "path", "to", "2", "thing", "resource", "bar"], path
-
-    path = @splat.make_path "%%/%4/bah%%2/thing/%%"
-    assert_equal %w{path to foo bahresource bar2 thing}, path
-  end
-end