kronk 1.5.4 → 1.6.0

data/test/test_path_matcher.rb

@@ -0,0 +1,329 @@
+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{\Afoo(.*)\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
+
+    matcher.find_in @data 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_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::PathMatch, 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::PathMatch, 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::PathMatch, 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]
+    ]
+
+    assert_equal expected_paths, (expected_paths | paths)
+    assert_equal Kronk::Path::PathMatch, 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_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(/\Atest(.*)\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(/\Aa|b\Z/,            @matcher.parse_node("a|b"))
+    assert_equal(/\Aa|b(c|d)\Z/,       @matcher.parse_node("a|b(c|d)"))
+
+    matcher = Kronk::Path::Matcher.new :regex_opts => Regexp::IGNORECASE
+    assert_equal(/\Aa|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_response.rb

@@ -166,11 +166,11 @@ class TestResponse < Test::Unit::TestCase
   def test_parsed_header
     assert_equal @json_resp.to_hash, @json_resp.parsed_header
 
-    assert_equal({'content-type' => ["application/json; charset=utf-8"]},
+    assert_equal({'content-type' => "application/json; charset=utf-8"},
                 @json_resp.parsed_header('Content-Type'))
 
-    assert_equal({'date'         => ["Fri, 03 Dec 2010 21:49:00 GMT"],
-                  'content-type' => ["application/json; charset=utf-8"]},
+    assert_equal({'date'         => "Fri, 03 Dec 2010 21:49:00 GMT",
+                  'content-type' => "application/json; charset=utf-8"},
                 @json_resp.parsed_header(['Content-Type', 'Date']))
 
     assert_nil @json_resp.parsed_header(false)
@@ -262,7 +262,7 @@ class TestResponse < Test::Unit::TestCase
   def test_selective_data_single_header
     body = JSON.parse @json_resp.body
     expected =
-      [{'content-type' => ['application/json; charset=utf-8']}, body]
+      [{'content-type' => 'application/json; charset=utf-8'}, body]
 
     assert_equal expected,
                  @json_resp.selective_data(:with_headers => "Content-Type")
@@ -272,8 +272,8 @@ class TestResponse < Test::Unit::TestCase
   def test_selective_data_multiple_headers
     body = JSON.parse @json_resp.body
     expected =
-      [{'content-type' => ['application/json; charset=utf-8'],
-        'date'         => ["Fri, 03 Dec 2010 21:49:00 GMT"]
+      [{'content-type' => 'application/json; charset=utf-8',
+        'date'         => "Fri, 03 Dec 2010 21:49:00 GMT"
       }, body]
 
     assert_equal expected,
@@ -284,10 +284,10 @@ class TestResponse < Test::Unit::TestCase
 
   def test_selective_data_no_body
     body = JSON.parse @json_resp.body
-    expected =
-      [{'content-type' => ['application/json; charset=utf-8'],
-        'date'         => ["Fri, 03 Dec 2010 21:49:00 GMT"]
-      }]
+    expected = {
+        'content-type' => 'application/json; charset=utf-8',
+        'date'         => "Fri, 03 Dec 2010 21:49:00 GMT"
+      }
 
     assert_equal expected,
                  @json_resp.selective_data(:no_body => true,

data/test/test_transaction.rb

@@ -28,6 +28,26 @@ class TestTransaction < Test::Unit::TestCase
   end
 
 
+  def test_many_transactions
+    data = @trans.run do |t|
+      t.map "key?"     => "thing%1",
+            "key3/*/0" => "key_value"
+      t.select "findme/0..1"
+      t.delete "findme/0"
+      t.move "findme/2" => "last_thing"
+    end
+
+    expected = {
+      "last_thing"=>{}, "key_value"=>"val1",
+      "thing1"=>{:key1a=>["foo", "bar", "foobar", {:findme=>"thing"}],
+        "key1b"=>"findme"},
+      "thing2"=>"foobar",
+      "thing3"=>{:key3a=>["val1", "val2", "val3"]}, "findme"=>[456]}
+
+    assert_equal expected, data
+  end
+
+
   def test_class_run
     block = lambda do |t|
       t.delete "key3/key*/2", "**=thing"
@@ -296,6 +316,114 @@ class TestTransaction < Test::Unit::TestCase
   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, "key*/key??" => "mapped/%1-%3",
+                                          "mapped"     => "remapped",
+                                          "**=thing"   => "more/one-%1",
+                                          "**=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", {:findme=>"thing"}],
+        "1-b"=>"findme", "3-a"=>["val1", "val2", "val3"]},
+      "more"=>{:findme=>"thing"}
+    }
+
+    data = @trans.transaction_map @data, "key*/key??" => "mapped/%1-%3",
+                                         "mapped"     => "remapped",
+                                         "**=thing"   => "more/%1"
+
+    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']]
+    new_data = @trans.remake_arrays new_data
+    assert_equal expected, new_data
+  end
+
+
   def test_ary_to_hash
     expected = {1 => :a, 0 => :foo, 2 => :b}
     assert_equal expected, @trans.ary_to_hash([:foo, :a, :b])
@@ -308,12 +436,13 @@ class TestTransaction < Test::Unit::TestCase
 
 
   def test_clear
-    @trans.instance_variable_get(:@actions)[:foo] = :bar
-    @trans.instance_variable_get(:@make_array) << :foobar
+    @trans.delete "foo"
+    @trans.select "bar"
 
     @trans.clear
 
-    assert @trans.instance_variable_get(:@actions).empty?
+    assert @trans.instance_variable_get(:@actions)[:delete].empty?
+    assert @trans.instance_variable_get(:@actions)[:select].empty?
     assert @trans.instance_variable_get(:@make_array).empty?
   end