cmpfs-ruby 0.2.0 → 0.2.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (15) hide show
  1. checksums.yaml +5 -5
  2. data/LICENSE +17 -16
  3. data/README.md +20 -9
  4. data/lib/cmpfs/compare/api_1_9.rb +121 -120
  5. data/lib/cmpfs/compare/api_2.rb +109 -108
  6. data/lib/cmpfs/compare/binary/internal_.rb +50 -52
  7. data/lib/cmpfs/compare/text/internal_.rb +89 -92
  8. data/lib/cmpfs/compare.rb +25 -23
  9. data/lib/cmpfs/version.rb +20 -19
  10. data/lib/cmpfs.rb +16 -12
  11. data/test/unit/compare/tc_compare_binary.rb +52 -51
  12. data/test/unit/tc_compare_binary.rb +53 -54
  13. data/test/unit/tc_compare_text.rb +85 -31
  14. data/test/unit/tc_version.rb +19 -16
  15. metadata +22 -17
data/lib/cmpfs/compare/binary/internal_.rb CHANGED
@@ -1,89 +1,87 @@
1
1
 
2
- #require 'xqsr3'
3
-
4
2
  require 'fileutils'
5
3
  require 'stringio'
6
4
 
5
+
7
6
  module CmpFS
8
7
  module Compare
9
8
  module Binary
10
9
 
11
10
  module Internal_
12
11
 
13
- def self.determine_param_type_ p
14
-
15
- case p
16
- when ::IO, ::StringIO
12
+ def self.determine_param_type_ p
17
13
 
18
- return :io
19
- when ::String
14
+ case p
15
+ when ::IO, ::StringIO
20
16
 
21
- return :path
22
- else
17
+ return :io
18
+ when ::String
23
19
 
24
- return :path if p.respond_to?(:to_str)
20
+ return :path
21
+ else
25
22
 
26
- return nil
27
- end
28
- end
23
+ return :path if p.respond_to?(:to_str)
29
24
 
30
- def self.compare_binary_files_ lhs_path, rhs_path, options
25
+ return nil
26
+ end
27
+ end
31
28
 
32
- FileUtils.compare_file lhs_path, rhs_path
33
- end
29
+ def self.compare_binary_files_ lhs_path, rhs_path, options
34
30
 
35
- def self.compare_binary_streams_ lhs_stm, rhs_stm, options
31
+ FileUtils.compare_file lhs_path, rhs_path
32
+ end
36
33
 
37
- FileUtils.compare_stream lhs_stm, rhs_stm
38
- end
34
+ def self.compare_binary_streams_ lhs_stm, rhs_stm, options
39
35
 
40
- def self.compare_binary_ lhs, rhs, options
36
+ FileUtils.compare_stream lhs_stm, rhs_stm
37
+ end
41
38
 
39
+ def self.compare_binary_ lhs, rhs, options
42
40
 
43
- lhs_type = self.determine_param_type_ lhs
44
- rhs_type = self.determine_param_type_ rhs
41
+ lhs_type = self.determine_param_type_ lhs
42
+ rhs_type = self.determine_param_type_ rhs
45
43
 
46
- raise ArgumentError, "lhs is of unsupported type '#{lhs.class}'" unless lhs_type
47
- raise ArgumentError, "rhs is of unsupported type '#{rhs.class}'" unless rhs_type
44
+ raise ArgumentError, "lhs is of unsupported type '#{lhs.class}'" unless lhs_type
45
+ raise ArgumentError, "rhs is of unsupported type '#{rhs.class}'" unless rhs_type
48
46
 
49
- if lhs_type == rhs_type
47
+ if lhs_type == rhs_type
50
48
 
51
- case lhs_type
52
- when :io
49
+ case lhs_type
50
+ when :io
53
51
 
54
- return self.compare_binary_streams_ lhs, rhs, options
55
- when :path
52
+ return self.compare_binary_streams_ lhs, rhs, options
53
+ when :path
56
54
 
57
- return self.compare_binary_files_ lhs, rhs, options
58
- end
59
- else
55
+ return self.compare_binary_files_ lhs, rhs, options
56
+ end
57
+ else
60
58
 
61
- case lhs_type
62
- when :io
59
+ case lhs_type
60
+ when :io
63
61
 
64
- if :path == rhs_type
62
+ if :path == rhs_type
65
63
 
66
- File.open(rhs, 'rb') do |rhs_f|
64
+ File.open(rhs, 'rb') do |rhs_f|
67
65
 
68
- return self.compare_binary_streams_ lhs, rhs_f, options
69
- end
70
- end
71
- when :path
66
+ return self.compare_binary_streams_ lhs, rhs_f, options
67
+ end
68
+ end
69
+ when :path
72
70
 
73
- if :path == lhs_type
71
+ if :path == lhs_type
74
72
 
75
- File.open(lhs, 'rb') do |lhs_f|
73
+ File.open(lhs, 'rb') do |lhs_f|
76
74
 
77
- return self.compare_binary_streams_ lhs_f, rhs, options
78
- end
79
- end
80
- end
81
- end
75
+ return self.compare_binary_streams_ lhs_f, rhs, options
76
+ end
77
+ end
78
+ end
79
+ end
82
80
 
83
- warn "#{__method__}: incompatible types (#{lhs.type}, #{rhs.type})"
81
+ warn "#{__method__}: incompatible types (#{lhs.type}, #{rhs.type})"
84
82
 
85
- nil
86
- end
83
+ nil
84
+ end
87
85
 
88
86
  end # module Internal_
89
87
 
@@ -91,6 +89,6 @@ end # module Binary
91
89
  end # module Compare
92
90
  end # module CmpFS
93
91
 
94
- # ############################## end of file ############################# #
95
92
 
93
+ # ############################## end of file ############################# #
96
94
 
data/lib/cmpfs/compare/text/internal_.rb CHANGED
@@ -1,159 +1,156 @@
1
1
 
2
- #require 'xqsr3'
3
-
4
2
  require 'fileutils'
5
3
  require 'stringio'
6
4
 
5
+
7
6
  module CmpFS
8
7
  module Compare
9
8
  module Text
10
9
 
11
10
  module Internal_
12
11
 
13
- def self.determine_param_type_ p
14
-
15
- case p
16
- when ::IO, ::StringIO
12
+ def self.determine_param_type_ p
17
13
 
18
- return :io
19
- when ::String
14
+ case p
15
+ when ::IO, ::StringIO
20
16
 
21
- return :path
22
- else
17
+ return :io
18
+ when ::String
23
19
 
24
- return :path if p.respond_to?(:to_str)
20
+ return :path
21
+ else
25
22
 
26
- return nil
27
- end
28
- end
23
+ return :path if p.respond_to?(:to_str)
29
24
 
30
- def self.next_line_or_nil_ en, options
25
+ return nil
26
+ end
27
+ end
31
28
 
32
- trimming_lines = options[:trim_lines]
33
- skipping_blanks = options[:skip_blank_lines]
29
+ def self.next_line_or_nil_ en, options
34
30
 
35
- num_read = 0
31
+ skipping_blanks = options[:skip_blank_lines]
32
+ trimming_lines = options[:trim_lines]
36
33
 
37
- begin
34
+ num_read = 0
38
35
 
39
- loop do
36
+ begin
40
37
 
41
- line = en.next
38
+ loop do
42
39
 
43
- num_read += 1
40
+ line = en.next
44
41
 
45
- line = line.strip if trimming_lines
42
+ num_read += 1
46
43
 
47
- if line.empty? && skipping_blanks
44
+ line = line.strip if trimming_lines
48
45
 
49
- next
50
- end
46
+ if line.empty? && skipping_blanks
51
47
 
52
- return [ line, num_read ]
53
- end
54
- rescue StopIteration
48
+ next
49
+ end
55
50
 
56
- end
51
+ return [ line, num_read ]
52
+ end
53
+ rescue StopIteration
57
54
 
58
- return [ nil, num_read ]
59
- end
55
+ end
60
56
 
61
- def self.compare_text_files_ lhs_path, rhs_path, options
57
+ return [ nil, num_read ]
58
+ end
62
59
 
63
- File.open(lhs_path, 'r') do |lhs_stm|
60
+ def self.compare_text_files_ lhs_path, rhs_path, options
64
61
 
65
- File.open(rhs_path, 'r') do |rhs_stm|
62
+ File.open(lhs_path, 'r') do |lhs_stm|
66
63
 
67
- self.compare_text_streams_ lhs_stm, rhs_stm, options.merge(no_rewind: true)
68
- end
69
- end
70
- end
64
+ File.open(rhs_path, 'r') do |rhs_stm|
71
65
 
72
- def self.compare_text_streams_ lhs_stm, rhs_stm, options
66
+ self.compare_text_streams_ lhs_stm, rhs_stm, options.merge(no_rewind: true)
67
+ end
68
+ end
69
+ end
73
70
 
74
- lhs_en = lhs_stm.each_line
75
- rhs_en = rhs_stm.each_line
71
+ def self.compare_text_streams_ lhs_stm, rhs_stm, options
76
72
 
77
- unless options[:no_rewind]
73
+ lhs_en = lhs_stm.each_line
74
+ rhs_en = rhs_stm.each_line
78
75
 
79
- lhs_en.rewind if lhs_stm.respond_to?(:rewind)
80
- rhs_en.rewind if rhs_stm.respond_to?(:rewind)
81
- end
76
+ unless options[:no_rewind]
82
77
 
83
- lhs_ix = 0
84
- rhs_ix = 0
78
+ lhs_en.rewind if lhs_stm.respond_to?(:rewind)
79
+ rhs_en.rewind if rhs_stm.respond_to?(:rewind)
80
+ end
85
81
 
86
- loop do
82
+ lhs_ix = 0
83
+ rhs_ix = 0
87
84
 
88
- lhs_ln, lhs_nr = self.next_line_or_nil_ lhs_en, options
89
- rhs_ln, rhs_nr = self.next_line_or_nil_ rhs_en, options
85
+ loop do
90
86
 
91
- if lhs_ln != rhs_ln
87
+ lhs_ln, lhs_nr = self.next_line_or_nil_ lhs_en, options
88
+ rhs_ln, rhs_nr = self.next_line_or_nil_ rhs_en, options
92
89
 
93
- return false
94
- else
90
+ if lhs_ln != rhs_ln
95
91
 
96
- return true if lhs_ln.nil?
97
- end
98
- end
92
+ return false
93
+ else
99
94
 
100
- return true
101
- end
95
+ return true if lhs_ln.nil?
96
+ end
97
+ end
102
98
 
103
- def self.compare_text_ lhs, rhs, options
99
+ return true
100
+ end
104
101
 
105
- lhs_type = self.determine_param_type_ lhs
106
- rhs_type = self.determine_param_type_ rhs
102
+ def self.compare_text_ lhs, rhs, options
107
103
 
108
- raise ArgumentError, "lhs is of unsupported type '#{lhs.class}'" unless lhs_type
109
- raise ArgumentError, "rhs is of unsupported type '#{rhs.class}'" unless rhs_type
104
+ lhs_type = self.determine_param_type_ lhs
105
+ rhs_type = self.determine_param_type_ rhs
110
106
 
111
- if lhs_type == rhs_type
107
+ raise ArgumentError, "lhs is of unsupported type '#{lhs.class}'" unless lhs_type
108
+ raise ArgumentError, "rhs is of unsupported type '#{rhs.class}'" unless rhs_type
112
109
 
113
- case lhs_type
114
- when :io
110
+ if lhs_type == rhs_type
115
111
 
116
- return self.compare_text_streams_ lhs, rhs, options
117
- when :path
112
+ case lhs_type
113
+ when :io
118
114
 
119
- return self.compare_text_files_ lhs, rhs, options
120
- end
121
- else
115
+ return self.compare_text_streams_ lhs, rhs, options
116
+ when :path
122
117
 
123
- case lhs_type
124
- when :io
118
+ return self.compare_text_files_ lhs, rhs, options
119
+ end
120
+ else
125
121
 
126
- if :path == rhs_type
122
+ case lhs_type
123
+ when :io
127
124
 
128
- File.open(rhs, 'r') do |rhs_f|
125
+ if :path == rhs_type
129
126
 
130
- return self.compare_text_streams_ lhs, rhs_f, options
131
- end
132
- end
133
- when :path
127
+ File.open(rhs, 'r') do |rhs_f|
134
128
 
135
- if :path == lhs_type
129
+ return self.compare_text_streams_ lhs, rhs_f, options
130
+ end
131
+ end
132
+ when :path
136
133
 
137
- File.open(lhs, 'r') do |lhs_f|
134
+ if :path == lhs_type
138
135
 
139
- return self.compare_text_streams_ lhs_f, rhs, options
140
- end
141
- end
142
- end
143
- end
136
+ File.open(lhs, 'r') do |lhs_f|
144
137
 
145
- warn "#{__method__}: incompatible types (#{lhs.type}, #{rhs.type})"
138
+ return self.compare_text_streams_ lhs_f, rhs, options
139
+ end
140
+ end
141
+ end
142
+ end
146
143
 
147
- nil
148
- end
144
+ warn "#{__method__}: incompatible types (#{lhs.type}, #{rhs.type})"
149
145
 
146
+ nil
147
+ end
150
148
  end # module Internal_
151
149
 
152
150
  end # module Text
153
151
  end # module Compare
154
152
  end # module CmpFS
155
153
 
156
- # ############################## end of file ############################# #
157
-
158
154
 
155
+ # ############################## end of file ############################# #
159
156
 
data/lib/cmpfs/compare.rb CHANGED
@@ -1,16 +1,17 @@
1
1
 
2
2
  # ######################################################################## #
3
- # File: cmpfs/version.rb
3
+ # File: cmpfs/version.rb
4
4
  #
5
- # Purpose: Version for cmpfs.Ruby library
5
+ # Purpose: Version for cmpfs.Ruby library
6
6
  #
7
- # Created: 1st March 2019
8
- # Updated: 13th March 2019
7
+ # Created: 1st March 2019
8
+ # Updated: 1st April 2024
9
9
  #
10
- # Home: http://github.com/synesissoftware/cmpfs.Ruby
10
+ # Home: http://github.com/synesissoftware/cmpfs.Ruby
11
11
  #
12
- # Author: Matthew Wilson
12
+ # Author: Matthew Wilson
13
13
  #
14
+ # Copyright (c) 2019-2024, Matthew Wilson and Synesis Information Systems
14
15
  # Copyright (c) 2019, Matthew Wilson and Synesis Software
15
16
  # All rights reserved.
16
17
  #
@@ -46,12 +47,13 @@
46
47
 
47
48
  if RUBY_VERSION >= '2'
48
49
 
49
- require 'cmpfs/compare/api_2'
50
+ require 'cmpfs/compare/api_2'
50
51
  else
51
52
 
52
- require 'cmpfs/compare/api_1_9'
53
+ require 'cmpfs/compare/api_1_9'
53
54
  end
54
55
 
56
+
55
57
  =begin
56
58
  =end
57
59
 
@@ -73,32 +75,32 @@ module CmpFS
73
75
  #
74
76
  module Compare
75
77
 
76
- def self.extended receiver
78
+ def self.extended receiver
77
79
 
78
- receiver.class_eval do
80
+ receiver.class_eval do
79
81
 
80
- extend CmpFS_Compare_Methods
81
- end
82
+ extend CmpFS_Compare_Methods
83
+ end
82
84
 
83
- $stderr.puts "#{receiver} extended by #{CmpFS_Compare_Methods}" if $DEBUG
84
- end
85
+ $stderr.puts "#{receiver} extended by #{CmpFS_Compare_Methods}" if $DEBUG
86
+ end
85
87
 
86
- def self.included receiver
88
+ def self.included receiver
87
89
 
88
- receiver.class_eval do
90
+ receiver.class_eval do
89
91
 
90
- include CmpFS_Compare_Methods
91
- end
92
+ include CmpFS_Compare_Methods
93
+ end
92
94
 
93
- $stderr.puts "#{receiver} included #{CmpFS_Compare_Methods}" if $DEBUG
94
- end
95
+ $stderr.puts "#{receiver} included #{CmpFS_Compare_Methods}" if $DEBUG
96
+ end
95
97
 
96
- extend CmpFS_Compare_Methods
97
- include CmpFS_Compare_Methods
98
+ extend CmpFS_Compare_Methods
99
+ include CmpFS_Compare_Methods
98
100
 
99
101
  end # module Compare
100
102
  end # module CmpFS
101
103
 
102
- # ############################## end of file ############################# #
103
104
 
105
+ # ############################## end of file ############################# #
104
106
 
data/lib/cmpfs/version.rb CHANGED
@@ -1,16 +1,17 @@
1
1
 
2
2
  # ######################################################################## #
3
- # File: cmpfs/version.rb
3
+ # File: cmpfs/version.rb
4
4
  #
5
- # Purpose: Version for cmpfs.Ruby library
5
+ # Purpose: Version for cmpfs.Ruby library
6
6
  #
7
- # Created: 1st March 2019
8
- # Updated: 13th March 2019
7
+ # Created: 1st March 2019
8
+ # Updated: 1st April 2024
9
9
  #
10
- # Home: http://github.com/synesissoftware/cmpfs.Ruby
10
+ # Home: http://github.com/synesissoftware/cmpfs.Ruby
11
11
  #
12
- # Author: Matthew Wilson
12
+ # Author: Matthew Wilson
13
13
  #
14
+ # Copyright (c) 2019-2024, Matthew Wilson and Synesis Information Systems
14
15
  # Copyright (c) 2019, Matthew Wilson and Synesis Software
15
16
  # All rights reserved.
16
17
  #
@@ -49,23 +50,23 @@
49
50
 
50
51
  module CmpFS
51
52
 
52
- # Current version of the cmpfs.Ruby library
53
- VERSION = '0.2.0'
53
+ # Current version of the cmpfs.Ruby library
54
+ VERSION = '0.2.1.1'
54
55
 
55
- private
56
- VERSION_PARTS_ = VERSION.split(/[.]/).collect { |n| n.to_i } # :nodoc:
57
- public
58
- # Major version of the cmpfs.Ruby library
59
- VERSION_MAJOR = VERSION_PARTS_[0] # :nodoc:
60
- # Minor version of the cmpfs.Ruby library
61
- VERSION_MINOR = VERSION_PARTS_[1] # :nodoc:
62
- # Revision version of the cmpfs.Ruby library
63
- VERSION_PATCH = VERSION_PARTS_[2] # :nodoc:
56
+ private
57
+ VERSION_PARTS_ = VERSION.split(/[.]/).collect { |n| n.to_i } # :nodoc:
58
+ public
59
+ # Major version of the cmpfs.Ruby library
60
+ VERSION_MAJOR = VERSION_PARTS_[0] # :nodoc:
61
+ # Minor version of the cmpfs.Ruby library
62
+ VERSION_MINOR = VERSION_PARTS_[1] # :nodoc:
63
+ # Revision version of the cmpfs.Ruby library
64
+ VERSION_PATCH = VERSION_PARTS_[2] # :nodoc:
64
65
 
65
- VERSION_REVISION = VERSION_PATCH # :nodoc:
66
+ VERSION_REVISION = VERSION_PATCH # :nodoc:
66
67
 
67
68
  end # module CmpFS
68
69
 
69
- # ############################## end of file ############################# #
70
70
 
71
+ # ############################## end of file ############################# #
71
72
 
data/lib/cmpfs.rb CHANGED
@@ -11,6 +11,7 @@
11
11
  #
12
12
  # Author: Matthew Wilson
13
13
  #
14
+ # Copyright (c) 2019-2024, Matthew Wilson and Synesis Information Systems
14
15
  # Copyright (c) 2019, Matthew Wilson and Synesis Software
15
16
  # All rights reserved.
16
17
  #
@@ -53,25 +54,28 @@ require 'cmpfs/version'
53
54
  ## Root module for *cmpfs*
54
55
  module CmpFS
55
56
 
56
- def self.extended receiver
57
+ def self.extended receiver
57
58
 
58
- receiver.class_eval do
59
+ receiver.class_eval do
59
60
 
60
- extend CmpFS::Compare
61
- end
61
+ extend CmpFS::Compare
62
+ end
62
63
 
63
- $stderr.puts "#{receiver} extended by #{CmpFS}" if $DEBUG
64
- end
64
+ $stderr.puts "#{receiver} extended by #{CmpFS}" if $DEBUG
65
+ end
65
66
 
66
- def self.included receiver
67
+ def self.included receiver
67
68
 
68
- receiver.class_eval do
69
+ receiver.class_eval do
69
70
 
70
- include CmpFS::Compare
71
- end
71
+ include CmpFS::Compare
72
+ end
72
73
 
73
- $stderr.puts "#{receiver} included #{CmpFS}" if $DEBUG
74
- end
74
+ $stderr.puts "#{receiver} included #{CmpFS}" if $DEBUG
75
+ end
75
76
 
76
77
  end # module CmpFS
77
78
 
79
+
80
+ # ############################## end of file ############################# #
81
+