libpath-ruby 0.2.1

data/lib/libpath/version.rb

@@ -0,0 +1,73 @@
+
+# ######################################################################## #
+# File:         libpath/version.rb
+#
+# Purpose:      Version for libpath.Ruby library
+#
+# Created:      8th January 2019
+# Updated:      16th April 2019
+#
+# Home:         http://github.com/synesissoftware/libpath.Ruby
+#
+# Author:       Matthew Wilson
+#
+# Copyright (c) 2019, Matthew Wilson and Synesis Software
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+#
+# * Neither the names of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# ######################################################################## #
+
+
+
+=begin
+=end
+
+module LibPath # :nodoc:
+
+	# Current version of the libpath.Ruby library
+	VERSION				=	'0.2.1'
+
+	private
+	VERSION_PARTS_		=	VERSION.split(/[.]/).collect { |n| n.to_i } # :nodoc:
+	public
+	# Major version of the libpath.Ruby library
+	VERSION_MAJOR		=	VERSION_PARTS_[0] # :nodoc:
+	# Minor version of the libpath.Ruby library
+	VERSION_MINOR		=	VERSION_PARTS_[1] # :nodoc:
+	# Patch version of the libpath.Ruby library
+	VERSION_PATCH		=	VERSION_PARTS_[2] # :nodoc:
+	# Revision version of the libpath.Ruby library
+	VERSION_REVISION	=	VERSION_PATCH # :nodoc:
+	# Sub-patch version of the libpath.Ruby library
+	VERSION_SUBPATCH	=	VERSION_PARTS_[3] # :nodoc:
+
+end # module LibPath
+
+# ############################## end of file ############################# #
+

data/test/performance/benchmark_drive_letter.rb

@@ -0,0 +1,31 @@
+#! /usr/bin/env ruby
+
+#############################################################################
+# File:         test/performance/benchmark_drive_letter.rb
+#
+# Purpose:      Determines whether it's better to use String-case of regex
+#               to match Windows-drive letters
+#
+# Created:      8th January 2019
+# Updated:      9th January 2019
+#
+# Author:       Matthew Wilson
+#
+#############################################################################
+
+$:.unshift File.join(File.dirname(__FILE__), *(['..'] * 2), 'lib')
+
+require 'libpath/internal_/windows/drive'
+
+require 'benchmark'
+
+ITERATIONS	=	100000
+
+ITEMS		=	(0...ITERATIONS).map { rand(0...100) }.map { |n| n > 51 ? ' ' : (n % 26 + (n < 26 ? 'A' : 'a').ord).chr }
+
+Benchmark.bm(10) do |x|
+
+	x.report('Regex:') { ITEMS.each { |ch| /^[a-z]/i =~ ch } }
+	x.report('cidl?:') { ITEMS.each { |ch| ::LibPath::Internal_::Windows::Drive.character_is_drive_letter?(ch) } }
+end
+

data/test/performance/benchmark_gsub_string_or_regex.rb

@@ -0,0 +1,45 @@
+#! /usr/bin/env ruby
+
+#############################################################################
+# File:         test/performance/benchmark_gsub_string_or_regex.rb
+#
+# Purpose:      Determine whether gsub using a string is faster than using a
+#               regex
+#
+# Created:      27th January 2019
+# Updated:      27th January 2019
+#
+# Author:       Matthew Wilson
+#
+#############################################################################
+
+$:.unshift File.join(File.dirname(__FILE__), *(['..'] * 2), 'lib')
+
+require 'benchmark'
+
+ITERATIONS	=	100000
+
+STRINGS	=	[
+
+	'abcdefghijklmnopqrstuvwxyz',
+	'a\\b/c\\d/e\\f/g\\h/i\\j/k\\l/m\\n/o\\p/q\\r/s\\t/u\\v/w\\x/y\\z/',
+	''
+]
+
+h = {
+	'/'	=>	'\\'
+}
+
+Benchmark.bm(24) do |x|
+
+	x.report('gsub by str:') { (0...ITERATIONS).each { STRINGS.each { |s| s.gsub('/', '\\') }}}
+	x.report('gsub by str (?):') { (0...ITERATIONS).each { STRINGS.each { |s| s.gsub('/', '\\') if s.include?('/') }}}
+	x.report('gsub by regex:') { (0...ITERATIONS).each { STRINGS.each { |s| s.gsub(/\//, '\\') }}}
+	x.report('gsub by regex (?):') { (0...ITERATIONS).each { STRINGS.each { |s| s.gsub(/\//, '\\') if s.include?('/') }}}
+	x.report('tr:') { (0...ITERATIONS).each { STRINGS.each { |s| s.tr('/', '\\') }}}
+	x.report('tr (?):') { (0...ITERATIONS).each { STRINGS.each { |s| s.tr('/', '\\') if s.include?('/') }}}
+	x.report('tr!:') { (0...ITERATIONS).each { STRINGS.each { |s| s.tr!('/', '\\') }}}
+
+	puts
+end
+

data/test/performance/benchmark_rindex2.rb

@@ -0,0 +1,109 @@
+#! /usr/bin/env ruby
+
+#############################################################################
+# File:         test/performance/benchmark_rindex2.rb
+#
+# Purpose:      Determines whether it's better to use rindex() twice for
+#               Windows-slashes or once with a regex
+#
+# Created:      8th January 2019
+# Updated:      8th January 2019
+#
+# Author:       Matthew Wilson
+#
+#############################################################################
+
+$:.unshift File.join(File.dirname(__FILE__), *(['..'] * 2), 'lib')
+
+require 'benchmark'
+
+ITERATIONS	=	100000
+
+SMALL_STRINGS	=	[
+
+	'C:\dir0\dir1/dir2',
+	'C:\dir0\dir1/dir2\dir3\dir4/',
+	'C:/dir0/dir1\dir2',
+]
+
+LONG_STRINGS	=	[
+
+	'C:' + '\dir' * 1000,
+	'C:' + '/dir' * 1000,
+	'C:' + '\dir/dir' * 500,
+]
+
+def by_two_calls(s)
+
+	ri_backward	=	s.rindex('\\')
+	ri_forward	=	s.rindex('/')
+
+	if ri_backward
+
+		if ri_forward
+
+			ri_forward > ri_backward ? ri_forward : ri_backward
+		else
+
+			ri_backward
+		end
+	else
+
+		ri_forward
+	end
+end
+
+def by_regex(s)
+
+	s.rindex(/[\\\/]/)
+end
+
+def by_manual(s)
+
+	(1..s.size).each do |ix|
+
+		ch = s[-ix]
+
+		if '/' == ch || '\\' == ch
+
+			return s.size - ix
+		end
+	end
+end
+
+# check
+
+SMALL_STRINGS.each do |ss|
+
+	r_2c	=	by_two_calls(ss)
+	r_re	=	by_regex(ss)
+	r_man	=	by_manual(ss)
+
+	if r_2c != r_re || r_2c != r_man
+
+		abort "For string '#{ss}' results differ: by_two_calls()=#{r_2c}; by_regex()=#{r_re}; by_manual()=#{r_man}"
+	end
+end
+
+LONG_STRINGS.each do |ss|
+
+	r_2c	=	by_two_calls(ss)
+	r_re	=	by_regex(ss)
+	r_man	=	by_manual(ss)
+
+	if r_2c != r_re || r_2c != r_man
+
+		abort "For string '#{ss}' results differ: by_two_calls()=#{r_2c}; by_regex()=#{r_re}; by_manual()=#{r_man}"
+	end
+end
+
+# benchmark
+
+Benchmark.bm(12) do |x|
+
+	x.report('rindex x 2:') { (0...ITERATIONS).each { SMALL_STRINGS.each { |ss| by_two_calls(ss) } } }
+	x.report('Regex:') { (0...ITERATIONS).each { SMALL_STRINGS.each { |ss| by_regex(ss) } } }
+	x.report('manual:') { (0...ITERATIONS).each { SMALL_STRINGS.each { |ss| by_manual(ss) } } }
+end
+
+

data/test/performance/benchmark_split.rb

@@ -0,0 +1,32 @@
+#! /usr/bin/env ruby
+
+#############################################################################
+# File:         test/performance/benchmark_split.rb
+#
+# Purpose:      Determines whether split is faster without regex
+#
+# Created:      15th January 2019
+# Updated:      15th January 2019
+#
+# Author:       Matthew Wilson
+#
+#############################################################################
+
+$:.unshift File.join(File.dirname(__FILE__), *(['..'] * 2), 'lib')
+
+require 'benchmark'
+
+ITERATIONS	=	10
+
+STRINGS		=	(1..1000).map { |n| '/abc' * n }
+
+# benchmark
+
+Benchmark.bm(15) do |x|
+
+	x.report('by char:') { (0...ITERATIONS).each { STRINGS.each { |s| s.split('/') } } }
+	x.report('by regex:') { (0...ITERATIONS).each { STRINGS.each { |s| s.split(/\//) } } }
+	x.report('by regex (sl):') { (0...ITERATIONS).each { STRINGS.each { |s| s.split(/[\\\/]/) } } }
+end
+
+

data/test/unit/compare/ts_all.rb

@@ -0,0 +1,22 @@
+#! /usr/bin/env ruby
+#
+# executes all other tests
+
+this_dir = File.expand_path(File.dirname(__FILE__))
+
+# all tc_*rb in current directory
+Dir[File.join(this_dir, 'tc_*rb')].each do |file|
+
+	$stderr.puts "requiring file '#{file}'" if $DEBUG
+
+	require file
+end
+
+# all ts_*rb in immediate sub-directories
+Dir[File.join(this_dir, '*', 'ts_*rb')].each do |file|
+
+	$stderr.puts "requiring file '#{file}'" if $DEBUG
+
+	require file
+end
+

data/test/unit/equate/ts_all.rb

@@ -0,0 +1,22 @@
+#! /usr/bin/env ruby
+#
+# executes all other tests
+
+this_dir = File.expand_path(File.dirname(__FILE__))
+
+# all tc_*rb in current directory
+Dir[File.join(this_dir, 'tc_*rb')].each do |file|
+
+	$stderr.puts "requiring file '#{file}'" if $DEBUG
+
+	require file
+end
+
+# all ts_*rb in immediate sub-directories
+Dir[File.join(this_dir, '*', 'ts_*rb')].each do |file|
+
+	$stderr.puts "requiring file '#{file}'" if $DEBUG
+
+	require file
+end
+

data/test/unit/equate/unix/ts_all.rb

@@ -0,0 +1,22 @@
+#! /usr/bin/env ruby
+#
+# executes all other tests
+
+this_dir = File.expand_path(File.dirname(__FILE__))
+
+# all tc_*rb in current directory
+Dir[File.join(this_dir, 'tc_*rb')].each do |file|
+
+	$stderr.puts "requiring file '#{file}'" if $DEBUG
+
+	require file
+end
+
+# all ts_*rb in immediate sub-directories
+Dir[File.join(this_dir, '*', 'ts_*rb')].each do |file|
+
+	$stderr.puts "requiring file '#{file}'" if $DEBUG
+
+	require file
+end
+

data/test/unit/equate/windows/ts_all.rb

@@ -0,0 +1,22 @@
+#! /usr/bin/env ruby
+#
+# executes all other tests
+
+this_dir = File.expand_path(File.dirname(__FILE__))
+
+# all tc_*rb in current directory
+Dir[File.join(this_dir, 'tc_*rb')].each do |file|
+
+	$stderr.puts "requiring file '#{file}'" if $DEBUG
+
+	require file
+end
+
+# all ts_*rb in immediate sub-directories
+Dir[File.join(this_dir, '*', 'ts_*rb')].each do |file|
+
+	$stderr.puts "requiring file '#{file}'" if $DEBUG
+
+	require file
+end
+

data/test/unit/exceptions/tc_libpath_base_exception.rb

@@ -0,0 +1,27 @@
+#! /usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), *(['..'] * 3), 'lib')
+
+require 'libpath/exceptions/libpath_base_exception'
+
+require 'xqsr3/extensions/test/unit'
+#require 'test/unit'
+
+class Test_LibPathBaseException < Test::Unit::TestCase
+
+	include ::LibPath::Exceptions
+
+	def test_exception_exists_and_is_a_class
+
+		assert defined?(LibPathBaseException)
+
+		assert LibPathBaseException.is_a?(::Class)
+	end
+
+	def test_cannot_be_initialised
+
+		assert_raise_with_message(::NoMethodError, /private.*method.*new.*LibPathBaseException/) { LibPathBaseException.new(nil) }
+	end
+end
+
+

data/test/unit/exceptions/tc_malformed_name_exception.rb

@@ -0,0 +1,31 @@
+#! /usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), *(['..'] * 3), 'lib')
+
+require 'libpath/exceptions/malformed_name_exception'
+
+require 'test/unit'
+
+class Test_MalformedNameException < Test::Unit::TestCase
+
+	include ::LibPath::Exceptions
+
+	def test_class_exists
+
+		assert defined?(MalformedNameException)
+
+		assert MalformedNameException.is_a?(::Class)
+	end
+
+	def test_can_be_initialised
+
+		mnx	=	MalformedNameException.new("abc\0def")
+
+		assert_not_nil mnx
+		assert_not_nil mnx.name
+		assert_match /abc.*def/, mnx.name
+		assert_match /malformed name 'abc.*def'/, mnx.message
+	end
+end
+
+