cmpfs-ruby 0.2.0 → 0.2.1.2

data/lib/cmpfs/compare/api_2.rb

@@ -1,127 +1,149 @@
 
 unless RUBY_VERSION >= '2'
 
-	abort "This file required Ruby 2+: RUBY_VERSION='#{RUBY_VERSION}'"
+  abort "This file required Ruby 2+: RUBY_VERSION='#{RUBY_VERSION}'"
 end
 
 require 'cmpfs/compare/binary/internal_'
 require 'cmpfs/compare/text/internal_'
 
+
 module CmpFS
 module Compare
 
 module CmpFS_Compare_Methods
 
-	# Compares two files, named by +lhs_path+ and +rhs_path+, in a binary
-	# (exact) manner
-	def compare_binary_files lhs_path, rhs_path, **options
-
-		::CmpFS::Compare::Binary::Internal_.compare_binary_files_ lhs_path, rhs_path, options
-	end
-
-	# Compares two streams, +lhs_stm+ and +rhs_stm+, in a binary
-	# (exact) manner
-	def compare_binary_streams lhs_stm, rhs_stm, **options
-
-		::CmpFS::Compare::Binary::Internal_.compare_binary_streams_ lhs_stm, rhs_stm, options
-	end
-
-	# Compares two files/streams in a binary (exact) manner
-	#
-	# == Signature
-	#
-	# == Return
-	#
-	# +true+ if the files/streams have exactly the same content; +false+
-	# otherwise.
-	def compare_binary lhs, rhs, **options
-
-		::CmpFS::Compare::Binary::Internal_.compare_binary_ lhs, rhs, options
-	end
-
-
-	# Compares two files, named by +lhs_path+ and +rhs_path+, in a textual
-	# manner according to the given +options+
-	#
-	# === Signature
-	#
-	# * *Parameters:*
-	#   - +lhs_path+:: (String) The name of a file
-	#   - +rhs_path+:: (String) The name of a file
-	#   - +options+:: (Hash) Options
-	#
-	# * *Options:*
-	#   - +:skip_blank_lines+:: (boolean) Determines whether blank lines
-	#      should be skipped from the comparison
-	#   - +:trim_lines+:: (boolean) Determines whether lines should be
-	#      trimmed of leading and trailing space (including EOL sequence)
-	#
-	# === Return
-	#
-	# +true+ if the files/streams have exactly the same content; +false+
-	# otherwise.
-	def compare_text_files lhs_path, rhs_path, **options
-
-		::CmpFS::Compare::Text::Internal_.compare_text_files_ lhs_path, rhs_path, options
-	end
-
-	# Compares two streams, named by +lhs_stm+ and +rhs_stm+, in a textual
-	# manner according to the given +options+
-	#
-	# === Signature
-	#
-	# * *Parameters:*
-	#   - +lhs_stm+:: (stream) A stream object
-	#   - +rhs_stm+:: (stream) A stream object
-	#   - +options+:: (Hash) Options
-	#
-	# * *Options:*
-	#   - +:no_rewind+:: (boolean) Prevents the default behaviour of
-	#      rewinding the stream before processing
-	#   - +:skip_blank_lines+:: (boolean) Determines whether blank lines
-	#      should be skipped from the comparison
-	#   - +:trim_lines+:: (boolean) Determines whether lines should be
-	#      trimmed of leading and trailing space (including EOL sequence)
-	#
-	# === Return
-	#
-	# +true+ if the files/streams have exactly the same content; +false+
-	# otherwise.
-	def compare_text_streams lhs_stm, rhs_stm, **options
-
-		::CmpFS::Compare::Text::Internal_.compare_text_streams_ lhs_stm, rhs_stm, options
-	end
-
-	# Compares two files/streams, named by +lhs+ and +rhs+, in a textual
-	# manner according to the given +options+
-	#
-	# === Signature
-	#
-	# * *Parameters:*
-	#   - +lhs+:: (String, stream) The name of a file, or a stream object
-	#   - +rhs+:: (String, stream) The name of a file, or a stream object
-	#   - +options+:: (Hash) Options
-	#
-	# * *Options:*
-	#   - +:no_rewind+:: (boolean) Prevents the default behaviour of
-	#      rewinding the stream before processing
-	#   - +:skip_blank_lines+:: (boolean) Determines whether blank lines
-	#      should be skipped from the comparison
-	#   - +:trim_lines+:: (boolean) Determines whether lines should be
-	#      trimmed of leading and trailing space (including EOL sequence)
-	#
-	# === Return
-	#
-	# +true+ if the files/streams have exactly the same content; +false+
-	# otherwise.
-	def compare_text lhs, rhs, **options
-
-		::CmpFS::Compare::Text::Internal_.compare_text_ lhs, rhs, options
-	end
+  # Compares two files, named by +lhs_path+ and +rhs_path+, in a binary
+  # (exact) manner
+  #
+  # === Signature
+  #
+  # * *Parameters:*
+  #   - +lhs_path+:: (+String+) The name of a file
+  #   - +rhs_path+:: (+String+) The name of a file
+  #   - +options+:: (+Hash+) Options that control the behaviour of the method
+  #
+  # * *Options:*
+  #
+  # === Return
+  # +true+ if the files have exactly the same content; +false+ otherwise.
+  def compare_binary_files lhs_path, rhs_path, **options
+
+    ::CmpFS::Compare::Binary::Internal_.compare_binary_files_ lhs_path, rhs_path, options
+  end
+
+  # Compares two streams, +lhs_stm+ and +rhs_stm+, in a binary
+  # (exact) manner
+  #
+  # === Signature
+  #
+  # * *Parameters:*
+  #   - +lhs_stm+:: (stream) A stream object
+  #   - +rhs_stm+:: (stream) A stream object
+  #   - +options+:: (+Hash+) Options that control the behaviour of the method
+  #
+  # * *Options:*
+  #   - +:no_rewind+:: (boolean) Prevents the default behaviour of rewinding each stream before processing
+  #
+  # === Return
+  # +true+ if the streams have exactly the same content; +false+ otherwise.
+  def compare_binary_streams lhs_stm, rhs_stm, **options
+
+    ::CmpFS::Compare::Binary::Internal_.compare_binary_streams_ lhs_stm, rhs_stm, options
+  end
+
+  # Compares two files/streams in a binary (exact) manner
+  #
+  # === Signature
+  #
+  # * *Parameters:*
+  #   - +lhs+:: (+String+, stream) The name of a file, or a stream object
+  #   - +rhs+:: (+String+, stream) The name of a file, or a stream object
+  #   - +options+:: (+Hash+) Options that control the behaviour of the method
+  #
+  # * *Options:*
+  #   - +:no_rewind+:: (boolean) Prevents the default behaviour of rewinding each stream before processing
+  #
+  # === Return
+  # +true+ if the files/streams have exactly the same content; +false+
+  # otherwise.
+  def compare_binary lhs, rhs, **options
+
+    ::CmpFS::Compare::Binary::Internal_.compare_binary_ lhs, rhs, options
+  end
+
+
+  # Compares two files, named by +lhs_path+ and +rhs_path+, in a textual
+  # manner according to the given +options+
+  #
+  # === Signature
+  #
+  # * *Parameters:*
+  #   - +lhs_path+:: (+String+) The name of a file
+  #   - +rhs_path+:: (+String+) The name of a file
+  #   - +options+:: (+Hash+) Options that control the behaviour of the method
+  #
+  # * *Options:*
+  #   - +:skip_blank_lines+:: (boolean) Determines whether blank lines should be skipped from the comparison
+  #   - +:trim_lines+:: (boolean) Determines whether lines should be trimmed of leading and trailing space (including EOL sequence)
+  #
+  # === Return
+  # +true+ if the files/streams have exactly the same content; +false+
+  # otherwise.
+  def compare_text_files lhs_path, rhs_path, **options
+
+    ::CmpFS::Compare::Text::Internal_.compare_text_files_ lhs_path, rhs_path, options
+  end
+
+  # Compares two streams, named by +lhs_stm+ and +rhs_stm+, in a textual
+  # manner according to the given +options+
+  #
+  # === Signature
+  #
+  # * *Parameters:*
+  #   - +lhs_stm+:: (stream) A stream object
+  #   - +rhs_stm+:: (stream) A stream object
+  #   - +options+:: (+Hash+) Options that control the behaviour of the method
+  #
+  # * *Options:*
+  #   - +:no_rewind+:: (boolean) Prevents the default behaviour of rewinding each stream before processing
+  #   - +:skip_blank_lines+:: (boolean) Determines whether blank lines should be skipped from the comparison
+  #   - +:trim_lines+:: (boolean) Determines whether lines should be trimmed of leading and trailing space (including EOL sequence)
+  #
+  # === Return
+  # +true+ if the files/streams have exactly the same content; +false+
+  # otherwise.
+  def compare_text_streams lhs_stm, rhs_stm, **options
+
+    ::CmpFS::Compare::Text::Internal_.compare_text_streams_ lhs_stm, rhs_stm, options
+  end
+
+  # Compares two files/streams, named by +lhs+ and +rhs+, in a textual
+  # manner according to the given +options+
+  #
+  # === Signature
+  #
+  # * *Parameters:*
+  #   - +lhs+:: (+String+, stream) The name of a file, or a stream object
+  #   - +rhs+:: (+String+, stream) The name of a file, or a stream object
+  #   - +options+:: (+Hash+) Options that control the behaviour of the method
+  #
+  # * *Options:*
+  #   - +:no_rewind+:: (boolean) Prevents the default behaviour of rewinding each stream before processing
+  #   - +:skip_blank_lines+:: (boolean) Determines whether blank lines should be skipped from the comparison
+  #   - +:trim_lines+:: (boolean) Determines whether lines should be trimmed of leading and trailing space (including EOL sequence)
+  #
+  # === Return
+  # +true+ if the files/streams have exactly the same content; +false+
+  # otherwise.
+  def compare_text lhs, rhs, **options
+
+    ::CmpFS::Compare::Text::Internal_.compare_text_ lhs, rhs, options
+  end
 end # module CmpFS_Compare_Methods
 end # module Compare
 end # module CmpFS
 
-# ############################## end of file ############################# #
 
+# ############################## end of file ############################# #
 

data/lib/cmpfs/compare/binary/internal_.rb

@@ -1,89 +1,87 @@
 
-#require 'xqsr3'
-
 require 'fileutils'
 require 'stringio'
 
+
 module CmpFS
 module Compare
 module Binary
 
 module Internal_
 
-		def self.determine_param_type_ p
-
-			case p
-			when ::IO, ::StringIO
+    def self.determine_param_type_ p
 
-				return :io
-			when ::String
+      case p
+      when ::IO, ::StringIO
 
-				return :path
-			else
+        return :io
+      when ::String
 
-				return :path if p.respond_to?(:to_str)
+        return :path
+      else
 
-				return nil
-			end
-		end
+        return :path if p.respond_to?(:to_str)
 
-		def self.compare_binary_files_ lhs_path, rhs_path, options
+        return nil
+      end
+    end
 
-			FileUtils.compare_file lhs_path, rhs_path
-		end
+    def self.compare_binary_files_ lhs_path, rhs_path, options
 
-		def self.compare_binary_streams_ lhs_stm, rhs_stm, options
+      FileUtils.compare_file lhs_path, rhs_path
+    end
 
-			FileUtils.compare_stream lhs_stm, rhs_stm
-		end
+    def self.compare_binary_streams_ lhs_stm, rhs_stm, options
 
-		def self.compare_binary_ lhs, rhs, options
+      FileUtils.compare_stream lhs_stm, rhs_stm
+    end
 
+    def self.compare_binary_ lhs, rhs, options
 
-			lhs_type	=	self.determine_param_type_ lhs
-			rhs_type	=	self.determine_param_type_ rhs
+      lhs_type  = self.determine_param_type_ lhs
+      rhs_type  = self.determine_param_type_ rhs
 
-			raise ArgumentError, "lhs is of unsupported type '#{lhs.class}'" unless lhs_type
-			raise ArgumentError, "rhs is of unsupported type '#{rhs.class}'" unless rhs_type
+      raise ArgumentError, "lhs is of unsupported type '#{lhs.class}'" unless lhs_type
+      raise ArgumentError, "rhs is of unsupported type '#{rhs.class}'" unless rhs_type
 
-			if lhs_type == rhs_type
+      if lhs_type == rhs_type
 
-				case lhs_type
-				when :io
+        case lhs_type
+        when :io
 
-					return self.compare_binary_streams_ lhs, rhs, options
-				when :path
+          return self.compare_binary_streams_ lhs, rhs, options
+        when :path
 
-					return self.compare_binary_files_ lhs, rhs, options
-				end
-			else
+          return self.compare_binary_files_ lhs, rhs, options
+        end
+      else
 
-				case lhs_type
-				when :io
+        case lhs_type
+        when :io
 
-					if :path == rhs_type
+          if :path == rhs_type
 
-						File.open(rhs, 'rb') do |rhs_f|
+            File.open(rhs, 'rb') do |rhs_f|
 
-							return self.compare_binary_streams_ lhs, rhs_f, options
-						end
-					end
-				when :path
+              return self.compare_binary_streams_ lhs, rhs_f, options
+            end
+          end
+        when :path
 
-					if :path == lhs_type
+          if :path == lhs_type
 
-						File.open(lhs, 'rb') do |lhs_f|
+            File.open(lhs, 'rb') do |lhs_f|
 
-							return self.compare_binary_streams_ lhs_f, rhs, options
-						end
-					end
-				end
-			end
+              return self.compare_binary_streams_ lhs_f, rhs, options
+            end
+          end
+        end
+      end
 
-			warn "#{__method__}: incompatible types (#{lhs.type}, #{rhs.type})"
+      warn "#{__method__}: incompatible types (#{lhs.type}, #{rhs.type})"
 
-			nil
-		end
+      nil
+    end
 
 end # module Internal_
 
@@ -91,6 +89,6 @@ end # module Binary
 end # module Compare
 end # module CmpFS
 
-# ############################## end of file ############################# #
 
+# ############################## end of file ############################# #
 

data/lib/cmpfs/compare/text/internal_.rb

@@ -1,159 +1,156 @@
 
-#require 'xqsr3'
-
 require 'fileutils'
 require 'stringio'
 
+
 module CmpFS
 module Compare
 module Text
 
 module Internal_
 
-		def self.determine_param_type_ p
-
-			case p
-			when ::IO, ::StringIO
+    def self.determine_param_type_ p
 
-				return :io
-			when ::String
+      case p
+      when ::IO, ::StringIO
 
-				return :path
-			else
+        return :io
+      when ::String
 
-				return :path if p.respond_to?(:to_str)
+        return :path
+      else
 
-				return nil
-			end
-		end
+        return :path if p.respond_to?(:to_str)
 
-		def self.next_line_or_nil_ en, options
+        return nil
+      end
+    end
 
-			trimming_lines	=	options[:trim_lines]
-			skipping_blanks	=	options[:skip_blank_lines]
+    def self.next_line_or_nil_ en, options
 
-			num_read		=	0
+      skipping_blanks = options[:skip_blank_lines]
+      trimming_lines  = options[:trim_lines]
 
-			begin
+      num_read = 0
 
-				loop do
+      begin
 
-					line = en.next
+        loop do
 
-					num_read += 1
+          line = en.next
 
-					line = line.strip if trimming_lines
+          num_read += 1
 
-					if line.empty? && skipping_blanks
+          line = line.strip if trimming_lines
 
-						next
-					end
+          if line.empty? && skipping_blanks
 
-					return [ line, num_read ]
-				end
-			rescue StopIteration
+            next
+          end
 
-			end
+          return [ line, num_read ]
+        end
+      rescue StopIteration
 
-			return [ nil, num_read ]
-		end
+      end
 
-		def self.compare_text_files_ lhs_path, rhs_path, options
+      return [ nil, num_read ]
+    end
 
-			File.open(lhs_path, 'r') do |lhs_stm|
+    def self.compare_text_files_ lhs_path, rhs_path, options
 
-				File.open(rhs_path, 'r') do |rhs_stm|
+      File.open(lhs_path, 'r') do |lhs_stm|
 
-					self.compare_text_streams_ lhs_stm, rhs_stm, options.merge(no_rewind: true)
-				end
-			end
-		end
+        File.open(rhs_path, 'r') do |rhs_stm|
 
-		def self.compare_text_streams_ lhs_stm, rhs_stm, options
+          self.compare_text_streams_ lhs_stm, rhs_stm, options.merge(no_rewind: true)
+        end
+      end
+    end
 
-			lhs_en	=	lhs_stm.each_line
-			rhs_en	=	rhs_stm.each_line
+    def self.compare_text_streams_ lhs_stm, rhs_stm, options
 
-			unless options[:no_rewind]
+      lhs_en  = lhs_stm.each_line
+      rhs_en  = rhs_stm.each_line
 
-				lhs_en.rewind if lhs_stm.respond_to?(:rewind)
-				rhs_en.rewind if rhs_stm.respond_to?(:rewind)
-			end
+      unless options[:no_rewind]
 
-			lhs_ix	=	0
-			rhs_ix	=	0
+        lhs_en.rewind if lhs_stm.respond_to?(:rewind)
+        rhs_en.rewind if rhs_stm.respond_to?(:rewind)
+      end
 
-			loop do
+      lhs_ix  = 0
+      rhs_ix  = 0
 
-				lhs_ln, lhs_nr	=	self.next_line_or_nil_ lhs_en, options
-				rhs_ln, rhs_nr	=	self.next_line_or_nil_ rhs_en, options
+      loop do
 
-				if lhs_ln != rhs_ln
+        lhs_ln, lhs_nr  = self.next_line_or_nil_ lhs_en, options
+        rhs_ln, rhs_nr  = self.next_line_or_nil_ rhs_en, options
 
-					return false
-				else
+        if lhs_ln != rhs_ln
 
-					return true if lhs_ln.nil?
-				end
-			end
+          return false
+        else
 
-			return true
-		end
+          return true if lhs_ln.nil?
+        end
+      end
 
-		def self.compare_text_ lhs, rhs, options
+      return true
+    end
 
-			lhs_type	=	self.determine_param_type_ lhs
-			rhs_type	=	self.determine_param_type_ rhs
+    def self.compare_text_ lhs, rhs, options
 
-			raise ArgumentError, "lhs is of unsupported type '#{lhs.class}'" unless lhs_type
-			raise ArgumentError, "rhs is of unsupported type '#{rhs.class}'" unless rhs_type
+      lhs_type  = self.determine_param_type_ lhs
+      rhs_type  = self.determine_param_type_ rhs
 
-			if lhs_type == rhs_type
+      raise ArgumentError, "lhs is of unsupported type '#{lhs.class}'" unless lhs_type
+      raise ArgumentError, "rhs is of unsupported type '#{rhs.class}'" unless rhs_type
 
-				case lhs_type
-				when :io
+      if lhs_type == rhs_type
 
-					return self.compare_text_streams_ lhs, rhs, options
-				when :path
+        case lhs_type
+        when :io
 
-					return self.compare_text_files_ lhs, rhs, options
-				end
-			else
+          return self.compare_text_streams_ lhs, rhs, options
+        when :path
 
-				case lhs_type
-				when :io
+          return self.compare_text_files_ lhs, rhs, options
+        end
+      else
 
-					if :path == rhs_type
+        case lhs_type
+        when :io
 
-						File.open(rhs, 'r') do |rhs_f|
+          if :path == rhs_type
 
-							return self.compare_text_streams_ lhs, rhs_f, options
-						end
-					end
-				when :path
+            File.open(rhs, 'r') do |rhs_f|
 
-					if :path == lhs_type
+              return self.compare_text_streams_ lhs, rhs_f, options
+            end
+          end
+        when :path
 
-						File.open(lhs, 'r') do |lhs_f|
+          if :path == lhs_type
 
-							return self.compare_text_streams_ lhs_f, rhs, options
-						end
-					end
-				end
-			end
+            File.open(lhs, 'r') do |lhs_f|
 
-			warn "#{__method__}: incompatible types (#{lhs.type}, #{rhs.type})"
+              return self.compare_text_streams_ lhs_f, rhs, options
+            end
+          end
+        end
+      end
 
-			nil
-		end
+      warn "#{__method__}: incompatible types (#{lhs.type}, #{rhs.type})"
 
+      nil
+    end
 end # module Internal_
 
 end # module Text
 end # module Compare
 end # module CmpFS
 
-# ############################## end of file ############################# #
-
 
+# ############################## end of file ############################# #