mug 0.5.3 → 0.5.4

data/test/test-rexproc.rb

@@ -3,10 +3,10 @@ $VERBOSE = true
 
 require_relative '../lib/mug/rexproc'
 class Test_rexproc < Test::Unit::TestCase
-	def test_rexproc
-		a = %w[foo bar baz]
-		assert_equal( %w[bar baz], a.select(&/\Ab/) )
-		assert_equal( %w[foo],     a.reject(&/\Ab/) )
-		assert_equal(  %[bar],     a.find(  &/\Ab/) )
-	end
+  def test_rexproc
+    a = %w[foo bar baz]
+    assert_equal( %w[bar baz], a.select(&/\Ab/) )
+    assert_equal( %w[foo],     a.reject(&/\Ab/) )
+    assert_equal(  %[bar],     a.find(  &/\Ab/) )
+  end
 end

data/test/test-self.rb

@@ -3,26 +3,26 @@ $VERBOSE = true
 
 require_relative '../lib/mug/self'
 class Test_self < Test::Unit::TestCase
-	def test_self
-		obj = Object.new
-		assert_equal( 1, 1.self )
-		assert_equal( obj, obj.self )
-		assert_equal( 6, 2.self{|i| i*3 } )
-		assert_equal( {1=>[1,1], 2=>[2,2], 3=>[3]}, [1,1,2,2,3].group_by(&:self) )
+  def test_self
+    obj = Object.new
+    assert_equal( 1, 1.self )
+    assert_equal( obj, obj.self )
+    assert_equal( 6, 2.self{|i| i*3 } )
+    assert_equal( {1=>[1,1], 2=>[2,2], 3=>[3]}, [1,1,2,2,3].group_by(&:self) )
 
-		assert_equal( 1, 1.itself )
-		assert_equal( obj, obj.itself )
-		assert_equal( 6, 2.itself{|i| i*3 } )
-		assert_equal( {1=>[1,1], 2=>[2,2], 3=>[3]}, [1,1,2,2,3].group_by(&:itself) )
-	end
-	def test_revapply
-		p = proc {|*args| args }
-		assert_equal( [1], 1.revapply(&p) )
-		assert_equal( [1,2,3], 1.revapply(2,3,&p) )
-		if RUBY_VERSION.to_i >= 2
-			assert_equal( 3, 1.revapply(2,3).size )
-		else
-			assert_equal( [1,2,3], 1.revapply(2,3).first )
-		end
-	end
+    assert_equal( 1, 1.itself )
+    assert_equal( obj, obj.itself )
+    assert_equal( 6, 2.itself{|i| i*3 } )
+    assert_equal( {1=>[1,1], 2=>[2,2], 3=>[3]}, [1,1,2,2,3].group_by(&:itself) )
+  end
+  def test_revapply
+    p = proc {|*args| args }
+    assert_equal( [1], 1.revapply(&p) )
+    assert_equal( [1,2,3], 1.revapply(2,3,&p) )
+    if RUBY_VERSION.to_i >= 2
+      assert_equal( 3, 1.revapply(2,3).size )
+    else
+      assert_equal( [1,2,3], 1.revapply(2,3).first )
+    end
+  end
 end

data/test/test-tau.rb

@@ -5,18 +5,18 @@ require 'bigdecimal/math'
 $VERBOSE = true
 require_relative '../lib/mug/tau'
 class Test_tau < Test::Unit::TestCase
-	def test_math_tau
-		# 6.283185307179586..
-		assert_equal(Math::TAU, Math::PI*2.0)
-	end
+  def test_math_tau
+    # 6.283185307179586..
+    assert_equal(Math::TAU, Math::PI*2.0)
+  end
 
-	include BigMath
-	def test_TAU
-		assert_equal(TAU(1).round(1).to_s('F'), '6.3')
-		assert_equal(TAU(100).truncate(100).to_s('F'), '6.2831853071795864769252867665590057683943387987502116419498891846156328125724179972560696506842341359')
-		assert_raise(ArgumentError) { TAU(0) }
-		assert_raise(ArgumentError) { TAU(-3) }
-		assert_raise(ArgumentError) { TAU('barf') }
-	end
+  include BigMath
+  def test_TAU
+    assert_equal(TAU(1).round(1).to_s('F'), '6.3')
+    assert_equal(TAU(100).truncate(100).to_s('F'), '6.2831853071795864769252867665590057683943387987502116419498891846156328125724179972560696506842341359')
+    assert_raise(ArgumentError) { TAU(0) }
+    assert_raise(ArgumentError) { TAU(-3) }
+    assert_raise(ArgumentError) { TAU('barf') }
+  end
 end
 

data/test/test-top.rb

@@ -4,113 +4,113 @@ $VERBOSE = true
 require_relative '../lib/mug/top'
 class Test_and_or < Test::Unit::TestCase
 
-	def test_top
-		a = [1,3,5,2,4,3]
-		assert_equal( [5], a.top )
-		assert_equal( [5,4,3], a.top(3) )
-		assert_equal( [5,4,3,3,2,1], a.top(100) )
-	end
-	def test_bottom
-		a = [3,1,4,3,2,5]
-		assert_equal( [1], a.bottom )
-		assert_equal( [1,2,3], a.bottom(3) )
-		assert_equal( [1,2,3,3,4,5], a.bottom(100) )
-	end
+  def test_top
+    a = [1,3,5,2,4,3]
+    assert_equal( [5], a.top )
+    assert_equal( [5,4,3], a.top(3) )
+    assert_equal( [5,4,3,3,2,1], a.top(100) )
+  end
+  def test_bottom
+    a = [3,1,4,3,2,5]
+    assert_equal( [1], a.bottom )
+    assert_equal( [1,2,3], a.bottom(3) )
+    assert_equal( [1,2,3,3,4,5], a.bottom(100) )
+  end
 
-	def test_top__block
-		a = [1,3,5,2,4,3]
-		b = proc{|x,y| y<=>x }
-		assert_equal( [1], a.top(&b) )
-		assert_equal( [1,2,3], a.top(3,&b) )
-		assert_equal( [1,2,3,3,4,5], a.top(100,&b) )
-	end
-	def test_bottom__block
-		a = [3,1,4,3,2,5]
-		b = proc{|x,y| y<=>x }
-		assert_equal( [5], a.bottom(&b) )
-		assert_equal( [5,4,3], a.bottom(3,&b) )
-		assert_equal( [5,4,3,3,2,1], a.bottom(100,&b) )
-	end
+  def test_top__block
+    a = [1,3,5,2,4,3]
+    b = proc{|x,y| y<=>x }
+    assert_equal( [1], a.top(&b) )
+    assert_equal( [1,2,3], a.top(3,&b) )
+    assert_equal( [1,2,3,3,4,5], a.top(100,&b) )
+  end
+  def test_bottom__block
+    a = [3,1,4,3,2,5]
+    b = proc{|x,y| y<=>x }
+    assert_equal( [5], a.bottom(&b) )
+    assert_equal( [5,4,3], a.bottom(3,&b) )
+    assert_equal( [5,4,3,3,2,1], a.bottom(100,&b) )
+  end
 
-	def test_top_by
-		a = [1,3,5,2,4,3]
-		b = proc{|x| x % 3 }
-		assert_equal( [5], a.top_by(&b) )
-		assert_equal( [5,2,1], a.top_by(3, &b) )
-		assert_equal( [5,2,1,4,3,3], a.top_by(100, &b) )
-	end
-	def test_bottom_by
-		a = [3,1,4,3,2,5]
-		b = proc{|x| x % 3 }
-		assert_equal( [3], a.bottom_by(&b) )
-		assert_equal( [3,3,1], a.bottom_by(3, &b) )
-		assert_equal( [3,3,1,4,2,5], a.bottom_by(100, &b) )
-	end
+  def test_top_by
+    a = [1,3,5,2,4,3]
+    b = proc{|x| x % 3 }
+    assert_equal( [5], a.top_by(&b) )
+    assert_equal( [5,2,1], a.top_by(3, &b) )
+    assert_equal( [5,2,1,4,3,3], a.top_by(100, &b) )
+  end
+  def test_bottom_by
+    a = [3,1,4,3,2,5]
+    b = proc{|x| x % 3 }
+    assert_equal( [3], a.bottom_by(&b) )
+    assert_equal( [3,3,1], a.bottom_by(3, &b) )
+    assert_equal( [3,3,1,4,2,5], a.bottom_by(100, &b) )
+  end
 
-	def test_top_by__noblock
-		a = [1,3,5,2,4,3]
-		b = proc{|x| x % 3 }
-		assert_equal( [5], a.top_by.each(&b) )
-		assert_equal( [5,2,1], a.top_by(3).each(&b) )
-		assert_equal( [5,2,1,4,3,3], a.top_by(100).each(&b) )
-	end
-	def test_bottom_by__noblock
-		a = [3,1,4,3,2,5]
-		b = proc{|x| x % 3 }
-		assert_equal( [3], a.bottom_by.each(&b) )
-		assert_equal( [3,3,1], a.bottom_by(3).each(&b) )
-		assert_equal( [3,3,1,4,2,5], a.bottom_by(100).each(&b) )
-	end
+  def test_top_by__noblock
+    a = [1,3,5,2,4,3]
+    b = proc{|x| x % 3 }
+    assert_equal( [5], a.top_by.each(&b) )
+    assert_equal( [5,2,1], a.top_by(3).each(&b) )
+    assert_equal( [5,2,1,4,3,3], a.top_by(100).each(&b) )
+  end
+  def test_bottom_by__noblock
+    a = [3,1,4,3,2,5]
+    b = proc{|x| x % 3 }
+    assert_equal( [3], a.bottom_by.each(&b) )
+    assert_equal( [3,3,1], a.bottom_by(3).each(&b) )
+    assert_equal( [3,3,1,4,2,5], a.bottom_by(100).each(&b) )
+  end
 
-	def test_topBANG
-		a = [1,3,5,2,4,3]
-		a.top!(3)
-		assert_equal( [5,4,3], a )
-	end
-	def test_bottomBANG
-		a = [3,1,4,3,2,5]
-		a.bottom!(3)
-		assert_equal( [1,2,3], a )
-	end
+  def test_topBANG
+    a = [1,3,5,2,4,3]
+    a.top!(3)
+    assert_equal( [5,4,3], a )
+  end
+  def test_bottomBANG
+    a = [3,1,4,3,2,5]
+    a.bottom!(3)
+    assert_equal( [1,2,3], a )
+  end
 
-	def test_topBANG__block
-		a = [1,3,5,2,4,3]
-		b = proc{|x,y| y<=>x }
-		a.top!(3, &b)
-		assert_equal( [1,2,3], a )
-	end
-	def test_bottomBANG__block
-		a = [3,1,4,3,2,5]
-		b = proc{|x,y| y<=>x }
-		a.bottom!(3, &b)
-		assert_equal( [5,4,3], a )
-	end
+  def test_topBANG__block
+    a = [1,3,5,2,4,3]
+    b = proc{|x,y| y<=>x }
+    a.top!(3, &b)
+    assert_equal( [1,2,3], a )
+  end
+  def test_bottomBANG__block
+    a = [3,1,4,3,2,5]
+    b = proc{|x,y| y<=>x }
+    a.bottom!(3, &b)
+    assert_equal( [5,4,3], a )
+  end
 
-	def test_top_byBANG
-		a = [1,3,5,2,4,3]
-		b = proc{|x| x % 3 }
-		a.top_by!(3, &b)
-		assert_equal( [5,2,1], a )
-	end
-	def test_bottom_byBANG
-		a = [3,1,4,3,2,5]
-		b = proc{|x| x % 3 }
-		a.bottom_by!(3, &b)
-		assert_equal( [3,3,1], a )
-	end
+  def test_top_byBANG
+    a = [1,3,5,2,4,3]
+    b = proc{|x| x % 3 }
+    a.top_by!(3, &b)
+    assert_equal( [5,2,1], a )
+  end
+  def test_bottom_byBANG
+    a = [3,1,4,3,2,5]
+    b = proc{|x| x % 3 }
+    a.bottom_by!(3, &b)
+    assert_equal( [3,3,1], a )
+  end
 
-	def test_top_byBANG__noblock
-		a = [1,3,5,2,4,3]
-		b = proc{|x| x % 3 }
-		a.top_by!(3).each(&b)
-		assert_equal( [5,2,1], a )
-	end
-	def test_bottom_byBANG__noblock
-		a = [3,1,4,3,2,5]
-		b = proc{|x| x % 3 }
-		a.bottom_by!(3).each(&b)
-		assert_equal( [3,3,1], a )
-	end
+  def test_top_byBANG__noblock
+    a = [1,3,5,2,4,3]
+    b = proc{|x| x % 3 }
+    a.top_by!(3).each(&b)
+    assert_equal( [5,2,1], a )
+  end
+  def test_bottom_byBANG__noblock
+    a = [3,1,4,3,2,5]
+    b = proc{|x| x % 3 }
+    a.bottom_by!(3).each(&b)
+    assert_equal( [3,3,1], a )
+  end
 
 end
 

metadata

@@ -1,21 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: mug
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - Matthew Kerwin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-21 00:00:00.000000000 Z
+date: 2016-11-01 00:00:00.000000000 Z
 dependencies: []
 description: |
   == MUG: Matty's Ultimate Gem
 
   A collection of wonders to astound the mind!!
 
-  See the documentation at https://github.com/phluid61/mug
+  See the documentation at http://phluid61.github.io/mug/
 email:
 - matthew@kerwin.net.au
 executables: []
@@ -103,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.2
+rubygems_version: 2.6.7
 signing_key: 
 specification_version: 4
 summary: 'MUG: Matty''s Ultimate Gem'