sarah 0.0.4 → 2.0.0

data/sarah.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name         = "sarah"
-  s.version      = "0.0.4"
-  s.date         = "2013-07-28"
+  s.version      = "2.0.0"
+  s.date         = "2014-03-31"
   s.authors      = ["Brian Katzung"]
   s.email        = ["briank@kappacs.com"]
   s.homepage     = "http://rubygems.org/gems/sarah"

data/test/05class2.rb

@@ -0,0 +1,49 @@
+require 'minitest/autorun'
+require 'sarah'
+
+# Class methods since 2.0.0
+
+class TestSarah_05 < MiniTest::Unit::TestCase
+
+    def test_cmethod
+	[ :[], :new, :try_convert
+	].each { |method| assert_respond_to Sarah, method }
+    end
+
+    def test_copy
+	s1 = Sarah[ 1, 2, 5 => 'five', :ten => 10 ]
+	s1.default = false
+	s1.negative_mode = :actual
+	s2 = Sarah.new s1
+
+	assert_equal s1.to_a, s2.to_a, 's1.to_a == s2.to_a'
+	assert_equal s1.to_h, s2.to_h, 's1.to_h == s2.to_h'
+	assert_equal :actual, s2.negative_mode, ':actual mode copied'
+	assert_equal false, s2.default, 'default copied'
+    end
+
+    def test_new
+	assert_equal [0, 'one', 5 => 'five', :ten => 10 ],
+	  Sarah[0, 'one', 5 => 'five', :ten => 10 ].to_a,
+	  'Failed to create Sarah literal'
+
+	assert_equal [0, 'one', {}],
+	  Sarah.new(:from => [0, 'one']).to_a,
+	  'Failed to create Sarah from array'
+
+	assert_equal [0, 'one', 5 => 'five', :ten => 10 ],
+	  Sarah.new(:from => { 0 => 0, 1 => 'one', 5 => 'five', :ten => 10 }).
+	  to_a, 'Failed to create Sarah from hash'
+
+	assert_equal [0, 'one', {}],
+	  Sarah.try_convert([0, 'one']).to_a,
+	  'Failed to try_convert array to Sarah'
+
+	assert_equal [0, 'one', 5 => 'five', :ten => 10 ],
+	  Sarah.try_convert({ 0 => 0, 1 => 'one', 5 => 'five', :ten => 10 }).
+	  to_a, 'Failed to try_convert hash to Sarah'
+    end
+
+end
+
+# END

data/test/06instance2.rb

@@ -0,0 +1,41 @@
+require 'minitest/autorun'
+require 'sarah'
+
+# Instance methods since 2.0,0
+
+class TestSarah_06 < MiniTest::Unit::TestCase
+
+    def setup
+	@s = Sarah.new
+    end
+
+    def test_imethods_accessors
+	[
+	  :default, :default=, :default_proc, :default_proc=,
+	  :negative_mode, :negative_mode=
+	].each { |method| assert_respond_to @s, method }
+    end
+
+    def test_imethods_user_api
+	[
+	  :&, :|, :+, :concat, :-, :<<, :push, :==, :eql?,
+	  :[], :at, :[]=, :store, :append!, :assoc,
+	  :clear, :collect!, :map!, :compact!, :count,
+	  :delete_at, :delete_key, :delete_if, :delete_value,
+	  :each, :each_index, :each_key, :each_pair, :empty?,
+	  :fetch, :find_index, :index, :first, :flatten!,
+	  :has_key?, :key?, :member?, :has_value?, :include?, :value?,
+	  :insert!, :inspect, :to_s, :join, :key, :keys,
+	  :last, :length, :size, :merge!, :update, :new_similar,
+	  :pairs_at, :pop, :rehash, :replace, :reverse!, :reverse_each,
+	  :rindex, :rotate!, :sample, :select, :set, :set_kv, :set_pairs,
+	  :shift, :shuffle, :shuffle!, :slice, :slice!, :sort, :sort!,
+	  :to_a, :to_h, :uniq, :uniq!, :unset_at, :unset_key,
+	  :unset_if, :unset_value, :unshift,
+	  :values, :values_at, :zip
+	].each { |method| assert_respond_to @s, method }
+    end
+
+end
+
+# END

data/test/07inst_attr.rb

@@ -0,0 +1,84 @@
+require 'minitest/autorun'
+require 'sarah'
+
+class TestSarah_07 < MiniTest::Unit::TestCase
+
+    def setup; @s = Sarah.new; end
+
+    def test_defaults
+	@s.default = true
+	assert_equal true, @s.default, 'Set default to true'
+	@s.default = false
+	assert_equal false, @s.default, 'Change default to false'
+
+	begin
+	    @s.default_proc = Proc.new { |s, k| true }
+	rescue
+	    assert false, 'Failed to set valid default_proc'
+	else
+	    assert true, 'Succeeded in setting valid default_proc'
+	    assert_kind_of Proc, @s.default_proc, 'Default_proc is a Proc'
+	end
+
+	begin
+	    @s.default_proc = nil
+	rescue
+	    assert false, 'Failed to set nil default_proc'
+	else
+	    assert_equal nil, @s.default_proc,
+	      'Succeeded in setting nil default_proc'
+	end
+
+	begin
+	    @s.default_proc = true
+	rescue TypeError
+	    assert true, 'Got TypeError for invalid default_proc'
+	rescue
+	    assert false, 'Got incorrect exception for invalid default_proc'
+	else
+	    assert false, 'No exception raised for invalid default_proc'
+	end
+    end
+
+    def test_neg_mode
+	@s.negative_mode = :ignore
+	@s.set 1, 2
+
+	assert_equal [1, 2], @s.values, 'Two values are correct'
+	assert_equal [0, 1], @s.keys, 'Two keys are correct'
+	assert_equal nil, @s[2], 'Key too big returns nil'
+	assert_equal nil, @s[-3], 'Ignore key too small returns nil'
+
+	@s.negative_mode = :error
+	begin
+	    value = @s[-3]
+	rescue IndexError
+	    assert true, 'Error key too small raises IndexError'
+	rescue
+	    assert false, 'Error key too small raises incorrect exception'
+	else
+	    assert false, 'Error key too small does not raise an exception'
+	end
+
+	@s.negative_mode = :actual
+	assert_equal nil, @s[-3], 'Negative key before set returns nil'
+	@s[-3] = '-3'
+	assert_equal '-3', @s[-3], 'Negative key after set is OK'
+
+	@s.negative_mode = :ignore
+	assert_equal :actual, @s.negative_mode,
+	  'Neg mode :ignore with negative key is ignored'
+
+	@s.negative_mode = :error
+	assert_equal :actual, @s.negative_mode,
+	  'Neg mode :error with negative key is ignored'
+
+	@s.shift
+	@s.negative_mode = :ignore
+	assert_equal :ignore, @s.negative_mode,
+	  'Neg mode :ignore after neg key removed is accepted'
+    end
+
+end
+
+# END

data/test/08set_ops.rb

@@ -0,0 +1,36 @@
+require 'minitest/autorun'
+require 'sarah'
+
+class TestSarah_08 < MiniTest::Unit::TestCase
+
+    def setup
+	@s1 = Sarah[1, 3, 4, 5, 'a', 'c', 'd', 'e', 20 => 'x', 21 => 'y']
+	@a1 = [1, 3, 4, 5, 'a', 'c', 'd', 'e', 'x', 'y']
+	@s2 = Sarah[1, 2, 3, 5, 'a', 'b', 'c', 'e', 20 => 'x', 22 => 'z']
+	@a2 = [1, 2, 3, 5, 'a', 'b', 'c', 'e', 'x', 'z']
+
+	@s3 = Sarah[ :a => ?a, :b => ?b, :c => ?c, :d => ?d, :x => 1 ]
+	@s4 = Sarah[ :b => ?b, :d => ?d, :e => ?e, :x => 2 ]
+    end
+
+    def test_inter
+	assert_equal((@a1 & @a2), (@s1 & @s2).values, 'Sarah ary intersection')
+	assert_equal({ :b => ?b, :d => ?d }, (@s3 & @s4).to_h,
+	  'Sarah rnd intersection')
+    end
+
+    def test_union
+	assert_equal((@a1 | @a2), (@s1 | @s2).values, 'Sarah ary union')
+	assert_equal({ :a => ?a, :b => ?b, :c => ?c, :d => ?d,
+	  :e => ?e, :x => 2}, (@s3 | @s4).to_h, 'Sarah rnd union')
+    end
+
+    def test_minus
+	assert_equal((@a1 - @a2), (@s1 - @s2).values, 'Sarah ary difference')
+	assert_equal({ :a => ?a, :c => ?c, :x => 1 }, (@s3 - @s4).to_h,
+	  'Sarah rnd difference')
+    end
+
+end
+
+# END

data/test/09delete_unset.rb

@@ -0,0 +1,135 @@
+require 'minitest/autorun'
+require 'sarah'
+
+class TestSarah_09 < MiniTest::Unit::TestCase
+
+    def test_clear
+	assert_equal({}, Sarah[ ?a, :b => ?c ].clear.to_h, 'clear :all')
+	assert_equal({ :b => ?c }, Sarah[ ?a, :b => ?c ].clear(:ary).to_h,
+	  'clear :ary')
+	assert_equal({ 0 => ?a }, Sarah[ ?a, :b => ?c ].clear(:rnd).to_h,
+	  'clear :rnd')
+    end
+
+    def test_delete_at
+	s = Sarah[ 0, 1, 2, 5 => 5, 7 => 7, 9 => 9,
+	  :a => ?a, :b => ?b, :c => ?c ]
+
+	assert_equal ?b, s.delete_at(:b), 'delete_at :b'
+	assert_equal 7, s.delete_at(7), 'delete_at 7'
+	assert_equal 1, s.delete_at(1), 'delete_at 1'
+	assert_equal [ 0, 2, 4 => 5, 7 => 9, :a => ?a, :c => ?c ], s.to_a,
+	  'after delete_at x3'
+    end
+
+    def test_delete_at_nma
+	s = Sarah.new([ 0, 1, 2, 5 => 5, 7 => 7, 9 => 9,
+	  :a => ?a, :b => ?b, :c => ?c ], :negative_mode => :actual)
+
+	assert_equal ?b, s.delete_at(:b), 'NMA delete_at :b'
+	assert_equal 7, s.delete_at(7), 'NMA delete_at 7'
+	assert_equal 1, s.delete_at(1), 'NMA delete_at 1'
+	assert_equal [ 0, 2 => 2, 5 => 5, 9 => 9, :a => ?a, :c => ?c ], s.to_a,
+	  'after NMA delete_at x3'
+    end
+
+    def test_delete_if
+	s = Sarah[1, 2, 3, 5 => 1, 6 => 2, 7 => 3, :a => 1, :b => 2, :c => 3]
+
+	s.delete_if(:ary) { |v, k| v == 1 }
+	assert_equal [2, 3, 4 => 2, 5 => 3, :a => 1, :b => 2, :c => 3 ],
+	  s.to_a, 'delete_if :ary == 1'
+
+	s.delete_if(:rnd) { |v, k| v == 2 }
+	assert_equal [2, 3, 4 => 2, 5 => 3, :a => 1, :c => 3 ],
+	  s.to_a, 'delete_if :rnd == 2'
+
+	s.delete_if { |v, k| v == 3 }
+	assert_equal [2, 3 => 2, :a => 1 ], s.to_a, 'delete_if == 3'
+    end
+
+    def test_delete_val
+	s = Sarah[1, 2, 3, 4, 6=>1, 7=>2, 8=>3, 9=>4, :a=>2, :b=>3 ]
+	s.delete_value 2, :rnd
+	assert_equal [1,2,3,4,1,2,3,4,3], s.values, 'delete_value 2, :rnd'
+	s.delete_value 1, :ary
+	assert_equal [2,3,4,2,3,4,3], s.values, 'delete_value 1, :ary'
+	s.delete_value 3
+	assert_equal [2,4,2,4], s.values, 'delete_value 3'
+    end
+
+    def test_pop
+	s = Sarah[ 0, 5 => 1, 7 => 2, 9 => 3, :a => ?a]
+	a = s.pop 2
+	assert_equal [ 2, 3 ], a, 'spr pop 2 ressult'
+	a = s.pop 2
+	assert_equal [ 0, 1 ], a, 'seq/spr pop 2 result'
+	assert_equal [ :a => ?a ], s.to_a, 'sarah after popping'
+    end
+
+    def test_shift
+	s = Sarah[ 0, 1, 2, 5 => 5, 7 => 7, 9 => 9,
+	  :a => ?a, :b => ?b, :c => ?c ]
+
+	v = s.shift
+	assert_equal 0, v, 'seq shift result'
+	assert_equal [ 1, 2, 4 => 5, 6 => 7, 8 => 9, :a => ?a, :b => ?b,
+	  :c => ?c ], s.to_a, 'sarah after shift'
+
+	a = s.shift 2
+	assert_equal [ 1, 2 ], a, 'seq shift 2 result'
+	assert_equal [ 2 => 5, 4 => 7, 6 => 9, :a => ?a, :b => ?b,
+	  :c => ?c ], s.to_a, 'sarah after shift 2'
+
+	s = Sarah[ 0, 5 => 1, 7 => 2, 9 => 3, :a => ?a]
+	a = s.shift 2
+	assert_equal [ 0, 1 ], a, 'seq/spr shift 2 result'
+	a = s.shift 2
+	assert_equal [ 2, 3 ], a, 'spr shift 2 ressult'
+	assert_equal [ :a => ?a ], s.to_a, 'sarah after shifting'
+    end
+
+    def test_unset_at
+	s = Sarah[ 0, 1, 2, 5 => 5, 7 => 7, 9 => 9,
+	  :a => ?a, :b => ?b, :c => ?c ]
+
+	assert_equal ?b, s.unset_at(:b), 'unset_at :b'
+	assert_equal 7, s.unset_at(7), 'unset_at 7'
+	assert_equal 1, s.unset_at(1), 'unset_at 1'
+	assert_equal [ 0, 2 => 2, 5 => 5, 9 => 9, :a => ?a, :c => ?c ], s.to_a,
+	  'after unset_at x3'
+    end
+
+    def test_unset_if
+	s = Sarah[1, 2, 3, 5 => 1, 6 => 2, 7 => 3, :a => 1, :b => 2, :c => 3]
+
+	s.unset_if(:ary) { |v, k| v == 1 }
+	assert_equal [1 => 2, 2 => 3, 6 => 2, 7 => 3,
+	  :a => 1, :b => 2, :c => 3 ], s.to_a, 'unset_if :ary == 1'
+
+	s.unset_if(:rnd) { |v, k| v == 2 }
+	assert_equal [1 => 2, 2 => 3, 6 => 2, 7 => 3, :a => 1, :c => 3 ],
+	  s.to_a, 'unset_if :rnd == 2'
+
+	s.unset_if { |v, k| v == 3 }
+	assert_equal [1 => 2, 6 => 2, :a => 1 ], s.to_a, 'unset_if == 3'
+    end
+
+    def test_unset_value
+	s = Sarah[1, 2, 3, 4, 6=>1, 7=>2, 8=>3, 9=>4, :a=>2, :b=>3 ]
+
+	s.unset_value 2, :rnd
+	assert_equal [1, 2, 3, 4, 6 => 1, 7 => 2, 8 => 3, 9 => 4, :b => 3],
+	  s.to_a, 'unset_value 2, :rnd'
+
+	s.unset_value 1, :ary
+	assert_equal [1 => 2, 2 => 3, 3 => 4, 7 => 2, 8 => 3, 9 => 4,
+	  :b => 3], s.to_a, 'unset_value 1, :ary'
+
+	s.unset_value 3
+	assert_equal [1 => 2, 3 => 4, 7 => 2, 9 => 4], s.to_a, 'unset_value 3'
+    end
+
+end
+
+# END

data/test/10count_size.rb

@@ -0,0 +1,36 @@
+require 'minitest/autorun'
+require 'sarah'
+
+class TestSarah_10 < MiniTest::Unit::TestCase
+
+    def test_count
+	s0 = Sarah[ 1, 3, 5 => 1, 6 => 3, :a => 3, :b => 5 ]
+
+	assert_equal 2, s0.count(:ary, 1), 'count :ary, 1'
+	assert_equal 4, s0.count(:ary) { |i| i.odd? }, 'count :ary, odd'
+	assert_equal 1, s0.count(:rnd, 3), 'count :rnd, 3'
+	assert_equal 2, s0.count(:rnd) { |i| i.odd? }, 'count :rnd, odd'
+	assert_equal 3, s0.count(:all, 3), 'count :all, 3'
+	assert_equal 6, s0.count(:all) { |i| i.odd? }, 'count :all, odd'
+	assert_equal 6, s0.count { |i| i.odd? }, 'count odd'
+    end
+
+    def test_size
+	s = Sarah[1, 2, 3, 4, 7 => 5, 8 => 6, :ix => 7]
+
+	assert_equal 4, s.size(:seq), 'size :seq'
+	assert_equal 2, s.size(:spr), 'size :spr'
+	assert_equal 6, s.size(:ary), 'size :ary'
+	assert_equal 1, s.size(:rnd), 'size :rnd'
+	assert_equal 7, s.size(:all), 'size :all'
+	assert_equal 7, s.size, 'size'
+
+	s.unset_value 3
+	assert_equal 2, s.size(:seq), 'size :seq after unset'
+	assert_equal 3, s.size(:spr), 'size :spr after unset'
+	assert_equal 5, s.size(:ary), 'size :ary after unset'
+    end
+
+end
+
+# END

data/test/11each.rb

@@ -0,0 +1,49 @@
+require 'minitest/autorun'
+require 'sarah'
+
+class TestSarah_11 < MiniTest::Unit::TestCase
+
+    def test_each
+	s = Sarah[1, 2, 5 => 3, 6 => 4, :a => 5, :b => 6]
+
+	h = {}
+	s.each(:seq) { |k, v| h[k] = v }
+	assert_equal({ 0 => 1, 1 => 2 }, h, 'each :seq')
+
+	h.clear
+	s.each(:spr) { |k, v| h[k] = v }
+	assert_equal({ 5 => 3, 6 => 4 }, h, 'each :spr')
+
+	h.clear
+	s.each(:ary) { |k, v| h[k] = v }
+	assert_equal({ 0 => 1, 1 => 2, 5 => 3, 6 => 4 }, h, 'each :ary')
+
+	h.clear
+	s.each(:rnd) { |k, v| h[k] = v }
+	assert_equal({ :a => 5, :b => 6 }, h, 'each :rnd')
+
+	h.clear
+	s.each(:all) { |k, v| h[k] = v }
+	assert_equal s.to_h, h, 'each :all'
+
+	a = []
+	s.reverse_each { |k, v| a << [k, v] }
+	assert_equal [[6, 4], [5, 3], [1, 2], [0, 1]], a, 'reverse_each'
+    end
+
+    def test_pairs_at
+	s = Sarah[1, 2, 5 => 3, 6 => 4, :a => 5, :b => 6]
+
+	assert_equal s.to_h, s.pairs_at(*s.keys), 'to_h matches pairs_at(*keys)'
+    end
+
+    def test_values_at
+	s = Sarah[1, 2, 5 => 3, 6 => 4, :a => 5, :b => 6]
+
+	assert_equal s.values, s.values_at(*s.keys),
+	  'values matches values_at(*keys)'
+    end
+
+end
+
+# END