ruby-path 1.0.0 → 1.0.1

data/History.rdoc

@@ -1,3 +1,9 @@
+=== 1.0.1 / 2012-07-18
+
+* Bugfixes:
+
+  * Update homepage
+
 === 1.0.0 / 2012-03-27
 
 * Major Enhancements:

data/Manifest.txt

@@ -12,3 +12,4 @@ test/test_path.rb
 test/test_core_ext.rb
 test/test_path_match.rb
 test/test_path_matcher.rb
+test/test_path_transaction.rb

data/README.rdoc

@@ -1,6 +1,6 @@
 = ruby-path
 
-* https://github.com/yaksnrainbows/ruby-path
+* https://yaks.me/ruby-path
 
 == DESCRIPTION:
 
@@ -42,8 +42,8 @@ Simple path-based search and lookup for Ruby.
 === Delete Data:
 
   data = {:foo => "bar", :foobar => [:a, :b, {:foo => "other bar"}, :c]}
-  data.replace_at_path "**=*bar", "BAR"
-  #=> {[:foo] => "bar", [:foobar, 2, :foo] => "other bar"}
+  data.delete_at_path "**=*bar"
+  #=> {:foobar => [:a, :b, {}, :c]}
 
 === Existance of Data:
 

data/lib/path.rb

@@ -32,7 +32,7 @@
 #   Path.find "root/**=\\1..3", data
 
 class Path
-  VERSION = '1.0.0'
+  VERSION = '1.0.1'
 
 
   # Used as path instruction to go up one path level.

data/lib/path/core_ext.rb

@@ -82,8 +82,8 @@ module Path::DataExt
   # Returns a hash of path/value pairs of deleted items.
   #
   #   data = {:foo => "bar", :foobar => [:a, :b, {:foo => "other bar"}, :c]}
-  #   data.replace_at_path "**=*bar", "BAR"
-  #   #=> {[:foo] => "bar", [:foobar, 2, :foo] => "other bar"}
+  #   data.delete_at_path "**=*bar"
+  #   #=> {:foobar => [:a, :b, {}, :c]}
 
   def delete_at_path path, limit=nil
     count = 0

data/test/test_path_transaction.rb

@@ -0,0 +1,520 @@
+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 = 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),
+      Path::Transaction.run(@data, &block)
+
+    assert_equal @trans.run(:keep_indicies => true, &block),
+      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 = 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 = 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 = 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 = 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-path
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-27 00:00:00.000000000 Z
+date: 2012-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -67,9 +67,10 @@ files:
 - test/test_core_ext.rb
 - test/test_path_match.rb
 - test/test_path_matcher.rb
+- test/test_path_transaction.rb
 - test/test_helper.rb
 - .gemtest
-homepage: https://github.com/yaksnrainbows/ruby-path
+homepage: https://yaks.me/ruby-path
 licenses: []
 post_install_message: 
 rdoc_options:
@@ -91,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: ruby-path
-rubygems_version: 1.8.18
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Simple path-based search and lookup for Ruby.
@@ -101,3 +102,4 @@ test_files:
 - test/test_path.rb
 - test/test_path_match.rb
 - test/test_path_matcher.rb
+- test/test_path_transaction.rb