mug 0.5.3 → 0.5.4

data/lib/mug/rexproc.rb

@@ -1,11 +1,11 @@
 
 class Regexp
-	#
-	# Matches the regexp against the parameter object.
-	#
-	def to_proc
-		lambda {|s| self =~ s }
-	end
+  #
+  # Matches the regexp against the parameter object.
+  #
+  def to_proc
+    lambda {|s| self =~ s }
+  end
 end
 
 =begin

data/lib/mug/self.rb

@@ -1,38 +1,38 @@
 
 class Object
-	#
-	# Returns this object.
-	#
-	# If a block is given, this object is yielded to it, and the result
-	# is returned.
-	#
-	def self(&block)
-		if block_given?
-			yield self
-		else
-			self
-		end
-	end
-	alias :itself :self
+  #
+  # Returns this object.
+  #
+  # If a block is given, this object is yielded to it, and the result
+  # is returned.
+  #
+  def self(&block)
+    if block_given?
+      yield self
+    else
+      self
+    end
+  end
+  alias :itself :self
 
-	# Deprecated alias for #self
-	def yield(&block) #:nodoc:
-		warn 'Object#yield is deprecated; use Object#self'
-		self.self(&block)
-	end
+  # Deprecated alias for #self
+  def yield(&block) #:nodoc:
+    warn 'Object#yield is deprecated; use Object#self'
+    self.self(&block)
+  end
 
-	#
-	# Yields this object (and any other arguments)
-	# to a block. If no block is given, returns an
-	# Enumerator.
-	#
-	def revapply(*args, &block)
-		if block_given?
-			yield self, *args
-		else
-			enum_for(:revapply, *args) { args.length + 1 }
-		end
-	end
+  #
+  # Yields this object (and any other arguments)
+  # to a block. If no block is given, returns an
+  # Enumerator.
+  #
+  def revapply(*args, &block)
+    if block_given?
+      yield self, *args
+    else
+      enum_for(:revapply, *args) { args.length + 1 }
+    end
+  end
 end
 
 =begin

data/lib/mug/to_h.rb

@@ -1,8 +1,8 @@
 
 if {}.respond_to? :to_h
-	warn %|Warning: "mug/to_h" has been removed as it conflicts with core to_h behaviour|
+  warn %|Warning: "mug/to_h" has been removed as it conflicts with core to_h behaviour|
 else
-	warn %|Warning: "mug/to_h" has been removed; see the "to_h" gem (https://rubygems.org/gems/to_h)|
+  warn %|Warning: "mug/to_h" has been removed; see the "to_h" gem (https://rubygems.org/gems/to_h)|
 end
 
 =begin

data/lib/mug/top.rb

@@ -1,113 +1,113 @@
 
 module Enumerable
 
-	#
-	# Get the top +n+ items, in order from top to bottom.
-	#
-	# Returns an +Array+ even when +n+ is 1.
-	#
-	# @see Enumerable#sort
-	#
-	def top n=1, &blk
-		if block_given?
-			sort{|x,y| yield y, x }[0...n]
-		else
-			#top_by(n) {|x| x }
-			if n <= length
-				sort[-n..-1].reverse
-			else
-				sort.reverse
-			end
-		end
-	end
+  #
+  # Get the top +n+ items, in order from top to bottom.
+  #
+  # Returns an +Array+ even when +n+ is 1.
+  #
+  # @see Enumerable#sort
+  #
+  def top n=1, &blk
+    if block_given?
+      sort{|x,y| yield y, x }[0...n]
+    else
+      #top_by(n) {|x| x }
+      if n <= length
+        sort[-n..-1].reverse
+      else
+        sort.reverse
+      end
+    end
+  end
 
-	#
-	# Get the top +n+ items, in order from top to bottom, ordered
-	# by mapping the values through the given block.
-	#
-	# Returns an +Array+ even when +n+ is 1. Values that are tied
-	# after mapping are returned in the initial order.
-	#
-	# If no block is given, an enumerator is returned instead.
-	#
-	# @see Enumerable#sort_by
-	#
-	def top_by n=1, &blk
-		return enum_for(:top_by, n) unless block_given?
-		chain = {}
-		each do |x|
-			y = yield x
-			chain[y] ||= []
-			chain[y] << x
-		end
-		ary = []
-		chain.keys.sort.reverse.each do |k|
-			ary += chain[k]
-			break if ary.length > n
-		end
-		ary[0...n]
-	end
+  #
+  # Get the top +n+ items, in order from top to bottom, ordered
+  # by mapping the values through the given block.
+  #
+  # Returns an +Array+ even when +n+ is 1. Values that are tied
+  # after mapping are returned in the initial order.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  # @see Enumerable#sort_by
+  #
+  def top_by n=1, &blk
+    return enum_for(:top_by, n) unless block_given?
+    chain = {}
+    each do |x|
+      y = yield x
+      chain[y] ||= []
+      chain[y] << x
+    end
+    ary = []
+    chain.keys.sort.reverse.each do |k|
+      ary += chain[k]
+      break if ary.length > n
+    end
+    ary[0...n]
+  end
 
-	#
-	# Get the bottom +n+ items, ordered from bottom to top.
-	#
-	# Returns an +Array+ even when +n+ is 1.
-	#
-	# @see Enumerable#sort
-	#
-	def bottom n=1, &blk
-		if block_given?
-			sort(&blk)[0...n]
-		else
-			#bottom_by(n) {|x| x }
-			sort[0...n]
-		end
-	end
+  #
+  # Get the bottom +n+ items, ordered from bottom to top.
+  #
+  # Returns an +Array+ even when +n+ is 1.
+  #
+  # @see Enumerable#sort
+  #
+  def bottom n=1, &blk
+    if block_given?
+      sort(&blk)[0...n]
+    else
+      #bottom_by(n) {|x| x }
+      sort[0...n]
+    end
+  end
 
-	#
-	# Get the bottom +n+ items, in order from bottom to top, ordered
-	# by mapping the values through the given block.
-	#
-	# Returns an +Array+ even when +n+ is 1. Values that are tied
-	# after mapping are returned in the initial order.
-	#
-	# If no block is given, an enumerator is returned instead.
-	#
-	# @see Enumerable#sort_by
-	#
-	def bottom_by n=1, &blk
-		return enum_for(:bottom_by, n) unless block_given?
-		chain = {}
-		each do |x|
-			y = yield x
-			chain[y] ||= []
-			chain[y] << x
-		end
-		ary = []
-		chain.keys.sort.each do |k|
-			ary += chain[k]
-			break if ary.length > n
-		end
-		ary[0...n]
-	end
+  #
+  # Get the bottom +n+ items, in order from bottom to top, ordered
+  # by mapping the values through the given block.
+  #
+  # Returns an +Array+ even when +n+ is 1. Values that are tied
+  # after mapping are returned in the initial order.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  # @see Enumerable#sort_by
+  #
+  def bottom_by n=1, &blk
+    return enum_for(:bottom_by, n) unless block_given?
+    chain = {}
+    each do |x|
+      y = yield x
+      chain[y] ||= []
+      chain[y] << x
+    end
+    ary = []
+    chain.keys.sort.each do |k|
+      ary += chain[k]
+      break if ary.length > n
+    end
+    ary[0...n]
+  end
 
 end
 
 class Array
-	def top! n=1, &blk
-		replace(top n, &blk)
-	end
-	def top_by! n=1, &blk
-		return enum_for(:top_by!, n) unless block_given?
-		replace(top_by n, &blk)
-	end
-	def bottom! n=1, &blk
-		replace(bottom n, &blk)
-	end
-	def bottom_by! n=1, &blk
-		return enum_for(:bottom_by!, n) unless block_given?
-		replace(bottom_by n, &blk)
-	end
+  def top! n=1, &blk
+    replace(top n, &blk)
+  end
+  def top_by! n=1, &blk
+    return enum_for(:top_by!, n) unless block_given?
+    replace(top_by n, &blk)
+  end
+  def bottom! n=1, &blk
+    replace(bottom n, &blk)
+  end
+  def bottom_by! n=1, &blk
+    return enum_for(:bottom_by!, n) unless block_given?
+    replace(bottom_by n, &blk)
+  end
 end
 
 =begin

data/test/test-and-or.rb

@@ -4,38 +4,38 @@ $VERBOSE = true
 require_relative '../lib/mug/and-or'
 class Test_and_or < Test::Unit::TestCase
 
-	def test_and
-		assert_equal( 2, 1.and(2) )
-		assert_equal( 2, 0.and(2) )
-		assert_equal( 2, 'x'.and(2) )
-		assert_equal( 2, true.and(2) )
-		assert_equal( false, false.and(2) )
-		assert_equal( nil,   nil.and(2) )
-	end
-
-	def test_and_2
-		assert_equal( [1], [1].and([2], &:empty?) )
-		assert_equal( [2], [].and([2], &:empty?) )
-		assert_equal( 'abc', 'abc'.and(''){|x|x =~ /\d/} )
-		assert_equal( '',    'a1c'.and(''){|x|x =~ /\d/} )
-	end
-
-
-	def test_or
-		assert_equal( 1,    1.or(2) )
-		assert_equal( 0,    0.or(2) )
-		assert_equal( 'x',  'x'.or(2) )
-		assert_equal( true, true.or(2) )
-		assert_equal( 2,    false.or(2) )
-		assert_equal( 2,    nil.or(2) )
-	end
-
-	def test_or_2
-		assert_equal( [2], [1].or([2], &:empty?) )
-		assert_equal( [],  [].or([2], &:empty?) )
-		assert_equal( '',    'abc'.or(''){|x|x =~ /\d/} )
-		assert_equal( 'a1c', 'a1c'.or(''){|x|x =~ /\d/} )
-	end
+  def test_and
+    assert_equal( 2, 1.and(2) )
+    assert_equal( 2, 0.and(2) )
+    assert_equal( 2, 'x'.and(2) )
+    assert_equal( 2, true.and(2) )
+    assert_equal( false, false.and(2) )
+    assert_equal( nil,   nil.and(2) )
+  end
+
+  def test_and_2
+    assert_equal( [1], [1].and([2], &:empty?) )
+    assert_equal( [2], [].and([2], &:empty?) )
+    assert_equal( 'abc', 'abc'.and(''){|x|x =~ /\d/} )
+    assert_equal( '',    'a1c'.and(''){|x|x =~ /\d/} )
+  end
+
+
+  def test_or
+    assert_equal( 1,    1.or(2) )
+    assert_equal( 0,    0.or(2) )
+    assert_equal( 'x',  'x'.or(2) )
+    assert_equal( true, true.or(2) )
+    assert_equal( 2,    false.or(2) )
+    assert_equal( 2,    nil.or(2) )
+  end
+
+  def test_or_2
+    assert_equal( [2], [1].or([2], &:empty?) )
+    assert_equal( [],  [].or([2], &:empty?) )
+    assert_equal( '',    'abc'.or(''){|x|x =~ /\d/} )
+    assert_equal( 'a1c', 'a1c'.or(''){|x|x =~ /\d/} )
+  end
 
 end
 

data/test/test-any-and-all.rb

@@ -3,23 +3,23 @@ $VERBOSE = true
 
 require_relative '../lib/mug/any-and-all'
 class Test_any_and_all < Test::Unit::TestCase
-	def test_any_and_all__block
-		b = proc {|o| o > 1 }
-		[
-			[ false, [] ],
-			[ false, [3,0,9] ],
-			[ true,  [3,5,9] ],
-		].each do |x, a|
-			assert_equal( x, a.any_and_all?(&b) )
-		end
-	end
-	def test_any_and_all__noblock
-		[
-			[ false, [] ],
-			[ false, [3,nil,9] ],
-			[ true,  [3,5,9] ],
-		].each do |x, a|
-			assert_equal( x, a.any_and_all? )
-		end
-	end
+  def test_any_and_all__block
+    b = proc {|o| o > 1 }
+    [
+      [ false, [] ],
+      [ false, [3,0,9] ],
+      [ true,  [3,5,9] ],
+    ].each do |x, a|
+      assert_equal( x, a.any_and_all?(&b) )
+    end
+  end
+  def test_any_and_all__noblock
+    [
+      [ false, [] ],
+      [ false, [3,nil,9] ],
+      [ true,  [3,5,9] ],
+    ].each do |x, a|
+      assert_equal( x, a.any_and_all? )
+    end
+  end
 end

data/test/test-apply.rb

@@ -2,55 +2,55 @@ require 'test/unit'
 $VERBOSE = true
 
 class Foo
-	def bar a, b
-		(a||0) + (b||0)
-	end
+  def bar a, b
+    (a||0) + (b||0)
+  end
 end
 
 require_relative '../lib/mug/apply'
 class Test_apply < Test::Unit::TestCase
-	def test_apply_proc
-		prc = proc{|a,b,*c| (a||0) + (b||0) + c.inject(0, &:+) }
-		p1 = prc.apply(1)
-		assert( p1.is_a? Proc )
-		assert_equal( 3, p1.apply(2) )
-		assert_equal( 3, prc.apply(1,2) )
-		assert_equal( 15, prc.apply(1,2,3,4,5) )
-	end
-	def test_apply_lambda
-		lmb = lambda{|a,b,c| (a||0) + (b||0) + (c||0) }
-
-		l1 = lmb.apply(1)
-		assert( l1.is_a? Proc )
-
-		l2 = l1.apply(2)
-		assert( l2.is_a? Proc )
-
-		assert_equal( 6, l2.apply(3) )
-		assert_equal( 6, l1.apply(2,3) )
-
-		assert_raise( ArgumentError ){ l2.apply(3, 4) }
-		assert_raise( ArgumentError ){ lmb.apply(1, 2, 3, 4) }
-	end
-	def test_apply_method
-		m1 = 1.method :+
-		assert_equal( 3, m1.apply(2) )
-		assert_raise( ArgumentError ){ m1.apply(2,3) }
-
-		m2 = Foo.new.method :bar
-		l1 = m2.apply(1)
-		assert( l1.is_a? Proc )
-
-		assert_equal( 3, l1.apply(2) )
-		assert_equal( 3, m2.apply(1,2) )
-
-		assert_raise( ArgumentError ){ l1.apply(2, 3) }
-		assert_raise( ArgumentError ){ m2.apply(1, 2, 3) }
-	end
-	def test_curry_method
-		m1 = 1.method :+
-		assert( m1.curry.is_a? Proc )
-		assert( m1.curry(1).is_a? Proc )
-		assert_raise( ArgumentError ){ m1.curry(2) }
-	end
+  def test_apply_proc
+    prc = proc{|a,b,*c| (a||0) + (b||0) + c.inject(0, &:+) }
+    p1 = prc.apply(1)
+    assert( p1.is_a? Proc )
+    assert_equal( 3, p1.apply(2) )
+    assert_equal( 3, prc.apply(1,2) )
+    assert_equal( 15, prc.apply(1,2,3,4,5) )
+  end
+  def test_apply_lambda
+    lmb = lambda{|a,b,c| (a||0) + (b||0) + (c||0) }
+
+    l1 = lmb.apply(1)
+    assert( l1.is_a? Proc )
+
+    l2 = l1.apply(2)
+    assert( l2.is_a? Proc )
+
+    assert_equal( 6, l2.apply(3) )
+    assert_equal( 6, l1.apply(2,3) )
+
+    assert_raise( ArgumentError ){ l2.apply(3, 4) }
+    assert_raise( ArgumentError ){ lmb.apply(1, 2, 3, 4) }
+  end
+  def test_apply_method
+    m1 = 1.method :+
+    assert_equal( 3, m1.apply(2) )
+    assert_raise( ArgumentError ){ m1.apply(2,3) }
+
+    m2 = Foo.new.method :bar
+    l1 = m2.apply(1)
+    assert( l1.is_a? Proc )
+
+    assert_equal( 3, l1.apply(2) )
+    assert_equal( 3, m2.apply(1,2) )
+
+    assert_raise( ArgumentError ){ l1.apply(2, 3) }
+    assert_raise( ArgumentError ){ m2.apply(1, 2, 3) }
+  end
+  def test_curry_method
+    m1 = 1.method :+
+    assert( m1.curry.is_a? Proc )
+    assert( m1.curry(1).is_a? Proc )
+    assert_raise( ArgumentError ){ m1.curry(2) }
+  end
 end