mug 0.5.3 → 0.5.4

data/test/test-array-extend.rb

@@ -2,66 +2,66 @@ require 'test/unit'
 $VERBOSE = true
 
 if RUBY_VERSION.to_f < 1.9
-	class Symbol
-		def next
-			to_s.next.to_sym
-		end
-	end
+  class Symbol
+    def next
+      to_s.next.to_sym
+    end
+  end
 end
 
 require_relative '../lib/mug/array/extend'
 class Test_array_extend < Test::Unit::TestCase
 
-	def test_array_extend_err
-		a = []
-		assert_raise(ArgumentError) { a.extend }
-		assert_raise(ArgumentError) { a.extend(1,2,3) }
-		assert_raise(ArgumentError) { a.extend(-1) }
-	end
-	def test_array_extend_1
-		a = [1,2]
-		assert_equal( [1,2,nil],     a.extend(1) )
-		assert_equal( [1,2,nil,nil], a.extend(2) )
-		assert_equal( [1,2,3],       a.extend(1,3) )
-		assert_equal( [1,2,3,3],     a.extend(2,3) )
-	end
-	def test_array_extend_2
-		a = [1,2]
-		b = [9,8]
-		assert_equal( [1,2,1,2], a.extend(a) )
-		assert_equal( [1,2,9,8], a.extend(b) )
-	end
-	def test_array_extend_3
-		a = ['a','b']
-		assert_equal( ['a','b',2,3,4], a.extend(3){|i| i } )
-		assert_equal( ['a','b'], a )
-	end
+  def test_array_extend_err
+    a = []
+    assert_raise(ArgumentError) { a.extend }
+    assert_raise(ArgumentError) { a.extend(1,2,3) }
+    assert_raise(ArgumentError) { a.extend(-1) }
+  end
+  def test_array_extend_1
+    a = [1,2]
+    assert_equal( [1,2,nil],     a.extend(1) )
+    assert_equal( [1,2,nil,nil], a.extend(2) )
+    assert_equal( [1,2,3],       a.extend(1,3) )
+    assert_equal( [1,2,3,3],     a.extend(2,3) )
+  end
+  def test_array_extend_2
+    a = [1,2]
+    b = [9,8]
+    assert_equal( [1,2,1,2], a.extend(a) )
+    assert_equal( [1,2,9,8], a.extend(b) )
+  end
+  def test_array_extend_3
+    a = ['a','b']
+    assert_equal( ['a','b',2,3,4], a.extend(3){|i| i } )
+    assert_equal( ['a','b'], a )
+  end
 
-	def test_array_extendbang_err
-		a = []
-		assert_raise(ArgumentError) { a.extend! }
-		assert_raise(ArgumentError) { a.extend!(1,2,3) }
-		assert_raise(ArgumentError) { a.extend!(-1) }
-	end
-	def test_array_extendbang_1
-		a = [1,2]
-		assert_equal( [1,2,nil],         a.extend!(1) )
-		assert_equal( [1,2,nil,nil,nil], a.extend!(2) )
-		a = [1,2]
-		assert_equal( [1,2,3],     a.extend!(1,3) )
-		assert_equal( [1,2,3,3,3], a.extend!(2,3) )
-	end
-	def test_array_extendbang_2
-		a = [1,2]
-		b = [9,8]
-		assert_equal( [1,2,1,2],     a.extend!(a) )
-		assert_equal( [1,2,1,2,9,8], a.extend!(b) )
-	end
-	def test_array_extendbang_3
-		a = ['a','b']
-		assert_equal( ['a','b',2,3,4], a.extend!(3){|i| i } )
-		assert_equal( ['a','b',2,3,4], a )
-	end
+  def test_array_extendbang_err
+    a = []
+    assert_raise(ArgumentError) { a.extend! }
+    assert_raise(ArgumentError) { a.extend!(1,2,3) }
+    assert_raise(ArgumentError) { a.extend!(-1) }
+  end
+  def test_array_extendbang_1
+    a = [1,2]
+    assert_equal( [1,2,nil],         a.extend!(1) )
+    assert_equal( [1,2,nil,nil,nil], a.extend!(2) )
+    a = [1,2]
+    assert_equal( [1,2,3],     a.extend!(1,3) )
+    assert_equal( [1,2,3,3,3], a.extend!(2,3) )
+  end
+  def test_array_extendbang_2
+    a = [1,2]
+    b = [9,8]
+    assert_equal( [1,2,1,2],     a.extend!(a) )
+    assert_equal( [1,2,1,2,9,8], a.extend!(b) )
+  end
+  def test_array_extendbang_3
+    a = ['a','b']
+    assert_equal( ['a','b',2,3,4], a.extend!(3){|i| i } )
+    assert_equal( ['a','b',2,3,4], a )
+  end
 end
 
 

data/test/test-array-minus.rb

@@ -4,16 +4,16 @@ $VERBOSE = true
 require_relative '../lib/mug/array/minus'
 class Test_array_minus < Test::Unit::TestCase
 
-	def test_array_minus
-		a = %w[q q w e r e e  ]
-		b = %w[q   w e   e   t]
-		c = %w[  q     r   e  ]
-		d = %w[              t]
-		assert_equal( c,     a.minus(b) )
-		assert_equal( d,     b.minus(a) )
-		assert_equal( c,     a.minus(b, remainder: false) )
-		assert_equal( [c,d], a.minus(b, remainder: true ) )
-		assert_equal( [d,c], b.minus(a, remainder: true ) )
-	end
+  def test_array_minus
+    a = %w[q q w e r e e  ]
+    b = %w[q   w e   e   t]
+    c = %w[  q     r   e  ]
+    d = %w[              t]
+    assert_equal( c,     a.minus(b) )
+    assert_equal( d,     b.minus(a) )
+    assert_equal( c,     a.minus(b, remainder: false) )
+    assert_equal( [c,d], a.minus(b, remainder: true ) )
+    assert_equal( [d,c], b.minus(a, remainder: true ) )
+  end
 end
 

data/test/test-bool.rb

@@ -2,9 +2,9 @@ require 'test/unit'
 $VERBOSE = true
 
 class MyEnum
-	include Enumerable
-	def initialize(*a) @a=a; end
-	def each(&b) @a.each(&b); end
+  include Enumerable
+  def initialize(*a) @a=a; end
+  def each(&b) @a.each(&b); end
 end
 
 if RUBY_VERSION.to_i >= 2
@@ -18,53 +18,53 @@ end
 require_relative '../lib/mug/bool'
 class Test_bool < Test::Unit::TestCase
 
-	alias :assert_true :assert
-	def assert_false val, msg=UNASSIGNED
-		assert !val, msg
-	end
-	def true_msg o, m=nil
-		m &&= ".#{m}"
-		"#{o.inspect}#{m} should be true"
-	end
-	def false_msg o, m=nil
-		m &&= ".#{m}"
-		"#{o.inspect}#{m} should be false"
-	end
+  alias :assert_true :assert
+  def assert_false val, msg=UNASSIGNED
+    assert !val, msg
+  end
+  def true_msg o, m=nil
+    m &&= ".#{m}"
+    "#{o.inspect}#{m} should be true"
+  end
+  def false_msg o, m=nil
+    m &&= ".#{m}"
+    "#{o.inspect}#{m} should be false"
+  end
 
-	def test_Bool
-		assert_true( Bool(true), true_msg(true) )
-		assert_false( Bool(false), false_msg(false) )
-		assert_false( Bool(nil), false_msg(false) )
-		$truthy.each do |o|
-			assert_true( Bool(o), true_msg(o) )
-		end
-		$falsy.each do |o|
-			assert_true( Bool(o), true_msg(o) )
-		end
-	end
+  def test_Bool
+    assert_true( Bool(true), true_msg(true) )
+    assert_false( Bool(false), false_msg(false) )
+    assert_false( Bool(nil), false_msg(false) )
+    $truthy.each do |o|
+      assert_true( Bool(o), true_msg(o) )
+    end
+    $falsy.each do |o|
+      assert_true( Bool(o), true_msg(o) )
+    end
+  end
 
-	def test_to_bool
-		assert_true( true.to_bool, true_msg(true,'to_bool') )
-		assert_false( false.to_bool, false_msg(false,'to_bool') )
-		assert_false( nil.to_bool, false_msg(nil,'to_bool') )
-		$truthy.each do |o|
-			assert_true( o.to_bool, true_msg(o,'to_bool') )
-		end
-		$falsy.each do |o|
-			assert_true( o.to_bool, true_msg(o,'to_bool') )
-		end
-	end
+  def test_to_bool
+    assert_true( true.to_bool, true_msg(true,'to_bool') )
+    assert_false( false.to_bool, false_msg(false,'to_bool') )
+    assert_false( nil.to_bool, false_msg(nil,'to_bool') )
+    $truthy.each do |o|
+      assert_true( o.to_bool, true_msg(o,'to_bool') )
+    end
+    $falsy.each do |o|
+      assert_true( o.to_bool, true_msg(o,'to_bool') )
+    end
+  end
 
-	def test_to_b
-		assert_true( true.to_b, true_msg(true,'to_b') )
-		assert_false( false.to_b, false_msg(false,'to_b') )
-		assert_false( nil.to_b, false_msg(nil,'to_b') )
-		$truthy.each do |o|
-			assert_true( o.to_b, true_msg(o,'to_b') )
-		end
-		$falsy.each do |o|
-			assert_false( o.to_b, false_msg(o,'to_b') )
-		end
-	end
+  def test_to_b
+    assert_true( true.to_b, true_msg(true,'to_b') )
+    assert_false( false.to_b, false_msg(false,'to_b') )
+    assert_false( nil.to_b, false_msg(nil,'to_b') )
+    $truthy.each do |o|
+      assert_true( o.to_b, true_msg(o,'to_b') )
+    end
+    $falsy.each do |o|
+      assert_false( o.to_b, false_msg(o,'to_b') )
+    end
+  end
 end
 

data/test/test-clamp.rb

@@ -4,48 +4,48 @@ $VERBOSE = true
 require_relative '../lib/mug/clamp'
 class Test_clamp < Test::Unit::TestCase
 
-	def test_clamp
-		[
-			[2,3],
-			[3,3],
-			[4,4],
-			[5,5],
-			[6,5],
-		].each do |num, ex|
-			assert_equal( ex, num.clamp(3,5) )
-		end
-		assert_raise(ArgumentError) { 0.clamp(5,3) }
-	end
-
-	def test_clamp__range
-		rng = 3..5
-		assert_equal( 3, 2.clamp(rng) )
-		assert_equal( 4, 4.clamp(rng) )
-		assert_equal( 5, 6.clamp(rng) )
-
-		rng = 3...5
-		assert_equal( 3, 2.clamp(rng) )
-		assert_equal( 4, 4.clamp(rng) )
-		assert_raise(ArgumentError) { 6.clamp(rng) }
-	end
-
-	def test_bound__inclusive
-		rng = 3..5
-		assert_equal( 3, rng.bound(2) )
-		assert_equal( 3, rng.bound(3) )
-		assert_equal( 4, rng.bound(4) )
-		assert_equal( 5, rng.bound(5) )
-		assert_equal( 5, rng.bound(6) )
-	end
-
-	def test_bound__exclusive
-		rng = 3...5
-		assert_equal( 3, rng.bound(2) )
-		assert_equal( 3, rng.bound(3) )
-		assert_equal( 4, rng.bound(4) )
-		assert_raise(ArgumentError) { rng.bound(5) }
-		assert_raise(ArgumentError) { rng.bound(6) }
-	end
+  def test_clamp
+    [
+      [2,3],
+      [3,3],
+      [4,4],
+      [5,5],
+      [6,5],
+    ].each do |num, ex|
+      assert_equal( ex, num.clamp(3,5) )
+    end
+    assert_raise(ArgumentError) { 0.clamp(5,3) }
+  end
+
+  def test_clamp__range
+    rng = 3..5
+    assert_equal( 3, 2.clamp(rng) )
+    assert_equal( 4, 4.clamp(rng) )
+    assert_equal( 5, 6.clamp(rng) )
+
+    rng = 3...5
+    assert_equal( 3, 2.clamp(rng) )
+    assert_equal( 4, 4.clamp(rng) )
+    assert_raise(ArgumentError) { 6.clamp(rng) }
+  end
+
+  def test_bound__inclusive
+    rng = 3..5
+    assert_equal( 3, rng.bound(2) )
+    assert_equal( 3, rng.bound(3) )
+    assert_equal( 4, rng.bound(4) )
+    assert_equal( 5, rng.bound(5) )
+    assert_equal( 5, rng.bound(6) )
+  end
+
+  def test_bound__exclusive
+    rng = 3...5
+    assert_equal( 3, rng.bound(2) )
+    assert_equal( 3, rng.bound(3) )
+    assert_equal( 4, rng.bound(4) )
+    assert_raise(ArgumentError) { rng.bound(5) }
+    assert_raise(ArgumentError) { rng.bound(6) }
+  end
 
 end
 

data/test/test-counts.rb

@@ -3,26 +3,26 @@ $VERBOSE = true
 
 require_relative '../lib/mug/counts'
 class Test_hashmap < Test::Unit::TestCase
-	def test_counts
-		a = %w(a b b c c c)
-		c = {'a'=>1, 'b'=>2, 'c'=>3}
-		assert_equal( c, a.counts )
-	end
-	def test_counts__block
-		a = %w(a b b c c c)
-		c = {'A'=>1, 'B'=>2, 'C'=>3}
-		assert_equal( c, a.counts{|i|i.upcase} )
-	end
-	def test_counts_by
-		a = %w(a b b c c c)
-		c = {'A'=>1, 'B'=>2, 'C'=>3}
-		assert_equal( c, a.counts_by{|i|i.upcase} )
-	end
-	def test_counts_by__noblock
-		a = %w(a b b c c c)
-		c = {'A'=>1, 'B'=>2, 'C'=>3}
-		e = a.counts_by
-		assert_equal( c, e.each{|i|i.upcase} )
-	end
+  def test_counts
+    a = %w(a b b c c c)
+    c = {'a'=>1, 'b'=>2, 'c'=>3}
+    assert_equal( c, a.counts )
+  end
+  def test_counts__block
+    a = %w(a b b c c c)
+    c = {'A'=>1, 'B'=>2, 'C'=>3}
+    assert_equal( c, a.counts{|i|i.upcase} )
+  end
+  def test_counts_by
+    a = %w(a b b c c c)
+    c = {'A'=>1, 'B'=>2, 'C'=>3}
+    assert_equal( c, a.counts_by{|i|i.upcase} )
+  end
+  def test_counts_by__noblock
+    a = %w(a b b c c c)
+    c = {'A'=>1, 'B'=>2, 'C'=>3}
+    e = a.counts_by
+    assert_equal( c, e.each{|i|i.upcase} )
+  end
 end
 

data/test/test-fragile-method-chain.rb

@@ -2,70 +2,70 @@ require 'test/unit'
 $VERBOSE = true
 
 module FMCTest
-	class A
-		def initialize; @b = B.new; end
-		attr_accessor :b
-	end
+  class A
+    def initialize; @b = B.new; end
+    attr_accessor :b
+  end
 
-	class B
-		def initialize; @c = C.new; end
-		attr_accessor :c
-	end
+  class B
+    def initialize; @c = C.new; end
+    attr_accessor :c
+  end
 
-	class C
-		def to_i; 1; end
-	end
+  class C
+    def to_i; 1; end
+  end
 end
 
 def false.c
-	2
+  2
 end
 
 require_relative '../lib/mug/fragile-method-chain'
 class Test_fmc < Test::Unit::TestCase
-	def test_fmc_nil
-		a = FMCTest::A.new
-		assert_equal( 1, a._?.b.c.to_i._! )
-		assert_equal( 1, a._?.b.c._!.to_i )
-		assert_equal( 1, a._?.b._!.c.to_i )
-		a.b.c = nil
-		assert_nil( a._?.b.c.to_i._! )
-		assert_equal( 0, a._?.b.c._!.to_i )
-		assert_equal( 0, a._?.b._!.c.to_i )
-		a.b = nil
-		assert_nil( a._?.b.c.to_i._! )
-		assert_equal( 0, a._?.b.c._!.to_i )
-		assert_raise(NoMethodError) { a._?.b._!.c.to_i }
-		a = nil
-		assert_nil( a._?.b.c.to_i._! )
-	end
-	def test_fmc_false
-		a = FMCTest::A.new
-		assert_equal( 1, a._?.b.c.to_i._! )
-		assert_equal( 1, a._?.b.c._!.to_i )
-		assert_equal( 1, a._?.b._!.c.to_i )
-		a.b.c = false
-		assert_equal( false, a._?.b.c.to_i._! )
-		assert_raise(NoMethodError) { a._?.b.c._!.to_i }
-		assert_raise(NoMethodError) { a._?.b._!.c.to_i }
-		a.b = false
-		assert_equal( false, a._?.b.c.to_i._! )
-		assert_raise(NoMethodError) { a._?.b.c._!.to_i }
-		assert_equal( 2, a._?.b._!.c.to_i )
-		a = false
-		assert_equal( false, a._?.b.c.to_i._! )
-		assert_raise(NoMethodError) { a._?.b.c._!.to_i }
-		assert_equal( 2, a._?.b._!.c.to_i )
-	end
-	def test_fmc_nested
-		a = FMCTest::A.new
-		assert_equal( 1, a._?.b._?.c._!.to_i._! )
-		a.b.c = false
-		assert_equal( false, a._?.b._?.c._!.to_i._! )
-		a.b = false
-		assert_equal( false, a._?.b._?.c._!.to_i._! )
-		a = false
-		assert_equal( false, a._?.b._?.c._!.to_i._! )
-	end
+  def test_fmc_nil
+    a = FMCTest::A.new
+    assert_equal( 1, a._?.b.c.to_i._! )
+    assert_equal( 1, a._?.b.c._!.to_i )
+    assert_equal( 1, a._?.b._!.c.to_i )
+    a.b.c = nil
+    assert_nil( a._?.b.c.to_i._! )
+    assert_equal( 0, a._?.b.c._!.to_i )
+    assert_equal( 0, a._?.b._!.c.to_i )
+    a.b = nil
+    assert_nil( a._?.b.c.to_i._! )
+    assert_equal( 0, a._?.b.c._!.to_i )
+    assert_raise(NoMethodError) { a._?.b._!.c.to_i }
+    a = nil
+    assert_nil( a._?.b.c.to_i._! )
+  end
+  def test_fmc_false
+    a = FMCTest::A.new
+    assert_equal( 1, a._?.b.c.to_i._! )
+    assert_equal( 1, a._?.b.c._!.to_i )
+    assert_equal( 1, a._?.b._!.c.to_i )
+    a.b.c = false
+    assert_equal( false, a._?.b.c.to_i._! )
+    assert_raise(NoMethodError) { a._?.b.c._!.to_i }
+    assert_raise(NoMethodError) { a._?.b._!.c.to_i }
+    a.b = false
+    assert_equal( false, a._?.b.c.to_i._! )
+    assert_raise(NoMethodError) { a._?.b.c._!.to_i }
+    assert_equal( 2, a._?.b._!.c.to_i )
+    a = false
+    assert_equal( false, a._?.b.c.to_i._! )
+    assert_raise(NoMethodError) { a._?.b.c._!.to_i }
+    assert_equal( 2, a._?.b._!.c.to_i )
+  end
+  def test_fmc_nested
+    a = FMCTest::A.new
+    assert_equal( 1, a._?.b._?.c._!.to_i._! )
+    a.b.c = false
+    assert_equal( false, a._?.b._?.c._!.to_i._! )
+    a.b = false
+    assert_equal( false, a._?.b._?.c._!.to_i._! )
+    a = false
+    assert_equal( false, a._?.b._?.c._!.to_i._! )
+  end
 end