xqsr3 0.38.1.1 → 0.39.1

data/test/unit/diagnostics/tc_exception_utilities.rb

@@ -8,218 +8,218 @@ require 'test/unit'
 
 class Test_ExceptionUtilities_raise_with_options < Test::Unit::TestCase
 
-	include ::Xqsr3::Diagnostics
+  include ::Xqsr3::Diagnostics
 
-	OS_IS_WINDOWS	=	(RUBY_PLATFORM =~ /(mswin|mingw|bccwin|wince)/i) ? true : false
-	LINE_NUM_RE		=	OS_IS_WINDOWS ? /.+:(\d+):/ : /^[^:]+:(\d+)/
+  OS_IS_WINDOWS = (RUBY_PLATFORM =~ /(mswin|mingw|bccwin|wince)/i) ? true : false
+  LINE_NUM_RE   = OS_IS_WINDOWS ? /.+:(\d+):/ : /^[^:]+:(\d+)/
 
-	class ArgumentErrorWithOptions < ArgumentError
-		def initialize(message = nil, **options)
-			super(message)
-			options	||= {}
-			@options = options
-		end
-		attr_reader :options
+  class ArgumentErrorWithOptions < ArgumentError
+    def initialize(message = nil, **options)
+      super(message)
+      options ||= {}
+      @options = options
+    end
+    attr_reader :options
 
-		def exception(msg = nil, options = nil)
+    def exception(msg = nil, options = nil)
 
-			return self if msg.nil?
-			return self if msg.object_id == self.object_id
+      return self if msg.nil?
+      return self if msg.object_id == self.object_id
 
-			msg		||=	self.message
-			options	||= {}
-			r = self.class.new msg, **self.options.merge(options)
-			r
-		end
-	end
+      msg ||= self.message
+      options ||= {}
+      r = self.class.new msg, **self.options.merge(options)
+      r
+    end
+  end
 
-	def execute(&block)
+  def execute(&block)
 
-		block.call
-	end
+    block.call
+  end
 
-	def test_0
+  def test_0
 
-		# standard raise: message-only
-		begin
-			raise "abc"
+    # standard raise: message-only
+    begin
+      raise "abc"
 
-			assert false, "should not get here"
-		rescue => x
+      assert false, "should not get here"
+    rescue => x
 
-			assert_kind_of(RuntimeError, x)
-			assert_equal "abc", x.message
-		end
+      assert_kind_of(RuntimeError, x)
+      assert_equal "abc", x.message
+    end
 
-		# RWO: message-only
-		begin
-			ExceptionUtilities.raise_with_options "abc"
+    # RWO: message-only
+    begin
+      ExceptionUtilities.raise_with_options "abc"
 
-			assert false, "should not get here"
-		rescue => x
+      assert false, "should not get here"
+    rescue => x
 
-			assert_kind_of(RuntimeError, x)
-			assert_equal "abc", x.message
-		end
-	end
+      assert_kind_of(RuntimeError, x)
+      assert_equal "abc", x.message
+    end
+  end
 
-	def test_1
+  def test_1
 
-		# standard raise: class
-		begin
-			raise ArgumentError
+    # standard raise: class
+    begin
+      raise ArgumentError
 
-			assert false, "should not get here"
-		rescue => x
+      assert false, "should not get here"
+    rescue => x
 
-			assert_kind_of(ArgumentError, x)
-			assert_equal "ArgumentError", x.message
-		end
+      assert_kind_of(ArgumentError, x)
+      assert_equal "ArgumentError", x.message
+    end
 
-		# RWO: class + message
-		begin
-			ExceptionUtilities.raise_with_options ArgumentError
+    # RWO: class + message
+    begin
+      ExceptionUtilities.raise_with_options ArgumentError
 
-			assert false, "should not get here"
-		rescue => x
+      assert false, "should not get here"
+    rescue => x
 
-			assert_kind_of(ArgumentError, x)
-			assert_equal "ArgumentError", x.message
-		end
-	end
+      assert_kind_of(ArgumentError, x)
+      assert_equal "ArgumentError", x.message
+    end
+  end
 
-	def test_2
+  def test_2
 
-		# standard raise: class + message
-		begin
-			raise ArgumentError, "abc"
+    # standard raise: class + message
+    begin
+      raise ArgumentError, "abc"
 
-			assert false, "should not get here"
-		rescue => x
+      assert false, "should not get here"
+    rescue => x
 
-			assert_kind_of(ArgumentError, x)
-			assert_equal "abc", x.message
-		end
+      assert_kind_of(ArgumentError, x)
+      assert_equal "abc", x.message
+    end
 
-		# RWO: class + message
-		begin
-			ExceptionUtilities.raise_with_options ArgumentError, "abc"
+    # RWO: class + message
+    begin
+      ExceptionUtilities.raise_with_options ArgumentError, "abc"
 
-			assert false, "should not get here"
-		rescue => x
+      assert false, "should not get here"
+    rescue => x
 
-			assert_kind_of(ArgumentError, x)
-			assert_equal "abc", x.message
-		end
-	end
+      assert_kind_of(ArgumentError, x)
+      assert_equal "abc", x.message
+    end
+  end
 
-	def test_2_b_no_options
+  def test_2_b_no_options
 
-		# standard raise: class + message
-		begin
-			raise ArgumentErrorWithOptions, "abc"
+    # standard raise: class + message
+    begin
+      raise ArgumentErrorWithOptions, "abc"
 
-			assert false, "should not get here"
-		rescue => x
+      assert false, "should not get here"
+    rescue => x
 
-			assert_kind_of(ArgumentError, x)
-			assert_equal "abc", x.message
-		end
+      assert_kind_of(ArgumentError, x)
+      assert_equal "abc", x.message
+    end
 
-		# RWO: class + message
-		begin
-			ExceptionUtilities.raise_with_options ArgumentErrorWithOptions, "abc"
+    # RWO: class + message
+    begin
+      ExceptionUtilities.raise_with_options ArgumentErrorWithOptions, "abc"
 
-			assert false, "should not get here"
-		rescue => x
+      assert false, "should not get here"
+    rescue => x
 
-			assert_kind_of(ArgumentError, x)
-			assert_equal "abc", x.message
-		end
-	end
+      assert_kind_of(ArgumentError, x)
+      assert_equal "abc", x.message
+    end
+  end
 
-	def test_2_b_with_options
+  def test_2_b_with_options
 
-		# standard raise: class + message + options
-		begin
-			raise ArgumentErrorWithOptions.new("abc", blah: :blech, id: 23)
+    # standard raise: class + message + options
+    begin
+      raise ArgumentErrorWithOptions.new("abc", blah: :blech, id: 23)
 
-			assert false, "should not get here"
-		rescue => x
+      assert false, "should not get here"
+    rescue => x
 
-			assert_kind_of(ArgumentError, x)
-			assert_equal "abc", x.message
-			assert_equal ({ :blah => :blech, :id => 23 }), x.options
-		end
+      assert_kind_of(ArgumentError, x)
+      assert_equal "abc", x.message
+      assert_equal ({ :blah => :blech, :id => 23 }), x.options
+    end
 
-		# RWO: class + message + options (raise-way)
-		begin
-			ExceptionUtilities.raise_with_options ArgumentErrorWithOptions.new("abc", blah: :blech, id: 23)
+    # RWO: class + message + options (raise-way)
+    begin
+      ExceptionUtilities.raise_with_options ArgumentErrorWithOptions.new("abc", blah: :blech, id: 23)
 
-			assert false, "should not get here"
-		rescue => x
+      assert false, "should not get here"
+    rescue => x
 
-			assert_kind_of(ArgumentError, x)
-			assert_equal "abc", x.message
-			assert_equal ({ :blah => :blech, :id => 23 }), x.options
-		end
+      assert_kind_of(ArgumentError, x)
+      assert_equal "abc", x.message
+      assert_equal ({ :blah => :blech, :id => 23 }), x.options
+    end
 
-		# RWO: class + message + options (raise_with_options-way)
-		begin
-			ExceptionUtilities.raise_with_options ArgumentErrorWithOptions, "abc", blah: :blech, id: 23
+    # RWO: class + message + options (raise_with_options-way)
+    begin
+      ExceptionUtilities.raise_with_options ArgumentErrorWithOptions, "abc", blah: :blech, id: 23
 
-			assert false, "should not get here"
-		rescue => x
+      assert false, "should not get here"
+    rescue => x
 
-			assert_kind_of(ArgumentError, x)
-			assert_equal "abc", x.message
-			assert_equal ({ :blah => :blech, :id => 23 }), x.options
-		end
-	end
+      assert_kind_of(ArgumentError, x)
+      assert_equal "abc", x.message
+      assert_equal ({ :blah => :blech, :id => 23 }), x.options
+    end
+  end
 
 
-	def test_with_backtrace
-		line_number	=	nil
+  def test_with_backtrace
+    line_number = nil
 
-		# standard raise: class + message + stack trace
-		begin
-			begin
-				execute { line_number = __LINE__; raise ArgumentError }
-			rescue => x
-				raise x, "abc", x.backtrace
-			end
+    # standard raise: class + message + stack trace
+    begin
+      begin
+        execute { line_number = __LINE__; raise ArgumentError }
+      rescue => x
+        raise x, "abc", x.backtrace
+      end
 
-			assert false, "should not get here"
-		rescue => x
+      assert false, "should not get here"
+    rescue => x
 
-			assert_kind_of(ArgumentError, x)
-			assert_equal "abc", x.message
+      assert_kind_of(ArgumentError, x)
+      assert_equal "abc", x.message
 
 
-			assert $@[0] =~ LINE_NUM_RE
-			assert_equal line_number.to_s, $1.to_s
-		end
+      assert $@[0] =~ LINE_NUM_RE
+      assert_equal line_number.to_s, $1.to_s
+    end
 
-		# RWO: class + message + stack trace
-		begin
-			begin
-				execute { line_number = __LINE__; ExceptionUtilities.raise_with_options ArgumentErrorWithOptions, blah: :blech, id: 23 }
+    # RWO: class + message + stack trace
+    begin
+      begin
+        execute { line_number = __LINE__; ExceptionUtilities.raise_with_options ArgumentErrorWithOptions, blah: :blech, id: 23 }
 
-				assert false, "should not get here"
-			rescue => x
-				raise x, "abc", x.backtrace
-			end
+        assert false, "should not get here"
+      rescue => x
+        raise x, "abc", x.backtrace
+      end
 
-			assert false, "should not get here"
-		rescue => x
+      assert false, "should not get here"
+    rescue => x
 
-			assert_kind_of(ArgumentError, x)
-			assert_equal "abc", x.message
-			assert_equal ({ :blah => :blech, :id => 23 }), x.options
+      assert_kind_of(ArgumentError, x)
+      assert_equal "abc", x.message
+      assert_equal ({ :blah => :blech, :id => 23 }), x.options
 
-			assert $@[0] =~ LINE_NUM_RE
-			assert_equal line_number.to_s, $1.to_s
-		end
-	end
+      assert $@[0] =~ LINE_NUM_RE
+      assert_equal line_number.to_s, $1.to_s
+    end
+  end
 end
 

data/test/unit/extensions/enumerable/tc_collect_with_index.rb

@@ -8,29 +8,29 @@ require 'test/unit'
 
 class Test_Enumerable_collect_with_index < Test::Unit::TestCase
 
-	def test_simple
+  def test_simple
 
-		ar = [ 1, -2, 3, -4, 5, -6 ]
+    ar = [ 1, -2, 3, -4, 5, -6 ]
 
-		r = ar.collect_with_index do |v, index0|
+    r = ar.collect_with_index do |v, index0|
 
-			index0 * v.abs
-		end
+      index0 * v.abs
+    end
 
-		assert_equal [ 0, 2, 6, 12, 20, 30 ], r
-	end
+    assert_equal [ 0, 2, 6, 12, 20, 30 ], r
+  end
 
-	def test_simple_with_offset
+  def test_simple_with_offset
 
-		ar = [ 1, -2, 3, -4, 5, -6 ]
+    ar = [ 1, -2, 3, -4, 5, -6 ]
 
-		r = ar.collect_with_index(1) do |v, index0|
+    r = ar.collect_with_index(1) do |v, index0|
 
-			index0 * v.abs
-		end
+      index0 * v.abs
+    end
 
-		assert_equal [ 1, 4, 9, 16, 25, 36 ], r
-	end
+    assert_equal [ 1, 4, 9, 16, 25, 36 ], r
+  end
 end
 
 

data/test/unit/extensions/enumerable/tc_detect_map.rb

@@ -10,34 +10,34 @@ require 'test/unit'
 
 class Test_Enumerable_detect_map < Test::Unit::TestCase
 
-	def test_with_array
+  def test_with_array
 
-		assert_nil [].detect_map { |v| nil }
-		assert_nil [ 1, 2, 3, 4, 5 ].detect_map { |v| nil }
+    assert_nil [].detect_map { |v| nil }
+    assert_nil [ 1, 2, 3, 4, 5 ].detect_map { |v| nil }
 
-		assert_nil [].detect_map { |v| :nil }
-		assert_not_nil [ 1, 2, 3, 4, 5 ].detect_map { |v| :nil }
+    assert_nil [].detect_map { |v| :nil }
+    assert_not_nil [ 1, 2, 3, 4, 5 ].detect_map { |v| :nil }
 
-		assert_nil [].detect_map { |v| return -2 * v }
-		assert_equal -2, [ 1, 2, 3, 4, 5 ].detect_map { |v| -2 * v }
-		assert_equal(-4, [ 1, 2, 3, 4, 5 ].detect_map { |v| -2 * v if 2 == v })
-	end
+    assert_nil [].detect_map { |v| return -2 * v }
+    assert_equal -2, [ 1, 2, 3, 4, 5 ].detect_map { |v| -2 * v }
+    assert_equal(-4, [ 1, 2, 3, 4, 5 ].detect_map { |v| -2 * v if 2 == v })
+  end
 
-	def test_with_hash
+  def test_with_hash
 
-		h1 = {}
-		h2 = { :abc => 'def', :ghi => 'jkl' }
+    h1 = {}
+    h2 = { :abc => 'def', :ghi => 'jkl' }
 
-		assert_nil h1.detect_map { |k, v| nil }
-		assert_nil h2.detect_map { |k, v| nil }
+    assert_nil h1.detect_map { |k, v| nil }
+    assert_nil h2.detect_map { |k, v| nil }
 
-		assert_nil h1.detect_map { |k, v| :nil }
-		assert_not_nil h2.detect_map { |k, v| :nil }
+    assert_nil h1.detect_map { |k, v| :nil }
+    assert_not_nil h2.detect_map { |k, v| :nil }
 
-		assert_nil h1.detect_map { |k, v| v.upcase }
-		assert_equal 'DEF', h2.detect_map { |k, v| v.upcase }
-		assert_equal 'JKL', h2.detect_map { |k, v| v.upcase if :ghi == k }
-	end
+    assert_nil h1.detect_map { |k, v| v.upcase }
+    assert_equal 'DEF', h2.detect_map { |k, v| v.upcase }
+    assert_equal 'JKL', h2.detect_map { |k, v| v.upcase if :ghi == k }
+  end
 end
 
 

data/test/unit/extensions/enumerable/tc_unique.rb

@@ -8,64 +8,64 @@ require 'test/unit'
 
 class Test_Enumerable_unique_test < Test::Unit::TestCase
 
-	def test_empty
+  def test_empty
 
-		src = []
+    src = []
 
-		dest = src.unique
+    dest = src.unique
 
-		assert dest.empty?
-	end
+    assert dest.empty?
+  end
 
-	def test_already_unique
+  def test_already_unique
 
-		src = [ 1, 2, 3, 4 ]
+    src = [ 1, 2, 3, 4 ]
 
-		dest = src.unique
+    dest = src.unique
 
-		assert_equal src, dest
-	end
+    assert_equal src, dest
+  end
 
-	def test_unique_contiguous
+  def test_unique_contiguous
 
-		src = [ 1, 2, 3, 3, 4 ]
+    src = [ 1, 2, 3, 3, 4 ]
 
-		dest = src.unique
+    dest = src.unique
 
-		assert_equal [ 1, 2, 3, 4], dest
-	end
+    assert_equal [ 1, 2, 3, 4], dest
+  end
 
-	def test_unique_noncontiguous
+  def test_unique_noncontiguous
 
-		src = [ 1, 2, 3, 4, 3 ]
+    src = [ 1, 2, 3, 4, 3 ]
 
-		dest = src.unique
+    dest = src.unique
 
-		assert_equal [ 1, 2, 3, 4], dest
-	end
+    assert_equal [ 1, 2, 3, 4], dest
+  end
 
-	def test_unique_very_large_sorted
+  def test_unique_very_large_sorted
 
-		max = 100000
+    max = 100000
 
-		src = (0...max).to_a * 2
-		exp = (0...max).to_a
+    src = (0...max).to_a * 2
+    exp = (0...max).to_a
 
-		dest = src.unique
+    dest = src.unique
 
-		assert_equal exp, dest
-	end
+    assert_equal exp, dest
+  end
 
-	def test_unique_very_large_unsorted
+  def test_unique_very_large_unsorted
 
-		max = 100000
+    max = 100000
 
-		src = ((0...max).to_a * 2).sort
-		exp = (0...max).to_a
+    src = ((0...max).to_a * 2).sort
+    exp = (0...max).to_a
 
-		dest = src.unique
+    dest = src.unique
 
-		assert_equal exp, dest
-	end
+    assert_equal exp, dest
+  end
 end
 

data/test/unit/extensions/hash/tc_deep_transform.rb

@@ -11,38 +11,38 @@ require 'stringio'
 
 class Test_Hash_deep_transform < Test::Unit::TestCase
 
-	def test_Hash_has_method
+  def test_Hash_has_method
 
-		assert Hash.new.respond_to? :deep_transform
-	end
+    assert Hash.new.respond_to? :deep_transform
+  end
 
-	def test_with_empty
+  def test_with_empty
 
-		assert_equal Hash.new, Hash.new.deep_transform { |k| k }
-		assert_equal Hash.new, Hash.new.deep_transform { |k, v| [ k, v ] }
-	end
+    assert_equal Hash.new, Hash.new.deep_transform { |k| k }
+    assert_equal Hash.new, Hash.new.deep_transform { |k, v| [ k, v ] }
+  end
 
-	def test_transform_to_same
+  def test_transform_to_same
 
-		jkl	=	12
-		h	=	{ 'abc' => 'def', ghi: jkl, mno: { p: 'q', 'r' => 'st' } }
+    jkl = 12
+    h = { 'abc' => 'def', ghi: jkl, mno: { p: 'q', 'r' => 'st' } }
 
-		assert_equal h, h.deep_transform { |k| k }
-		assert_equal h, h.deep_transform { |k, v| [ k, v ] }
-	end
+    assert_equal h, h.deep_transform { |k| k }
+    assert_equal h, h.deep_transform { |k, v| [ k, v ] }
+  end
 
-	def test_transform_to_symbolise_keys
+  def test_transform_to_symbolise_keys
 
-		jkl	=	12
-		h	=	{ 'abc' => 'def', ghi: jkl, mno: { p: 'q', 'r' => 'st' } }
+    jkl = 12
+    h = { 'abc' => 'def', ghi: jkl, mno: { p: 'q', 'r' => 'st' } }
 
-		h_1	=	{ abc: 'def', ghi: jkl, mno: { p: 'q', r: 'st' } }
-		h_2	=	{ abc: :def, ghi: jkl, mno: { p: :q, r: :st } }
+    h_1 = { abc: 'def', ghi: jkl, mno: { p: 'q', r: 'st' } }
+    h_2 = { abc: :def, ghi: jkl, mno: { p: :q, r: :st } }
 
-		assert_equal h_1, h.deep_transform { |k| k.respond_to?(:to_sym) ? k.to_sym : k }
-		assert_equal h_1, h.deep_transform { |k, v| [ k.respond_to?(:to_sym) ? k.to_sym : k, v ] }
-		assert_equal h_2, h.deep_transform { |k, v| [ k.respond_to?(:to_sym) ? k.to_sym : k, v.respond_to?(:to_sym) ? v.to_sym : v ] }
-	end
+    assert_equal h_1, h.deep_transform { |k| k.respond_to?(:to_sym) ? k.to_sym : k }
+    assert_equal h_1, h.deep_transform { |k, v| [ k.respond_to?(:to_sym) ? k.to_sym : k, v ] }
+    assert_equal h_2, h.deep_transform { |k, v| [ k.respond_to?(:to_sym) ? k.to_sym : k, v.respond_to?(:to_sym) ? v.to_sym : v ] }
+  end
 end