fingerprint 1.2.4 → 1.3.0

data/README.md

@@ -10,11 +10,22 @@ disk. It also provides a programmatic interface for this procedure.
 
 Because Fingerprint produces output to `IO` like structures, it is easy to transmit
 this data across a network, or store it for later use. As an example, it could be
-used to check the integrity of a backup.
+used to check the integrity of a remote backup.
 
-For examples please see the main [project page][1].
+For examples and documentation please see the main [project page][1].
 
-[1]: http://www.oriontransfer.co.nz/projects/admin-toolbox/fingerprint
+[1]: http://www.oriontransfer.co.nz/gems/fingerprint
+
+Todo
+----
+
+* Command line option to show files that have been created (e.g. don't exist in master fingerprint).
+* Command line option to show files that have changed but have the same modified time (hardware corrutpion).
+* Command line option to check fingerprint files based on checksums, e.g. duplicate files, unique files, over a set of directories.
+* Command line tool for extracting duplicate and unique files over a set of directories?
+* Supporting tools for signing fingerprints easily.
+* Support indexing specific files as well as whole directories (maybe?).
+* Support general filenames for `--archive`, e.g. along with `-n`, maybe support a file called `index.fingerprint` by default: improved visibility for end user.
 
 License
 -------

data/bin/fingerprint

@@ -27,32 +27,34 @@ require 'fingerprint'
 OPTIONS = {
 	:root => "./",
 	:mode => :scan,
-	:output => nil,
+	:output => $stdout,
 	:verbose => false,
 	:force => false,
-	:name => "._fingerprint.txt"
+	:name => "._index.fingerprint",
+	:extended => false,
+	:checksums => Fingerprint::DEFAULT_CHECKSUMS,
 }
 
 ARGV.options do |o|
 	script_name = File.basename($0)
 
 	o.banner = "Usage: #{script_name} [options] [path]"
-	o.define_head "This script is used to calculate and compare a basic file system fingerprint."
+	o.define_head "This script is used to create and compare file system fingerprints."
 
 	o.separator ""
 	o.separator "Directory analysis and verification:"
 	
-	o.on("--analyze [path]", String, "Generage a fingerprint of the given path and save it for later verification.") do |path|
+	o.on("-a", "--analyze [path]", String, "Generage a fingerprint of the given path and save it for later verification.") do |path|
 		OPTIONS[:mode] = :analyze
-		OPTIONS[:root] = path
+		OPTIONS[:root] = path if path
 	end
 	
-	o.on("--verify [path]", String, "Verify a given path based on a previously saved fingerprint.") do |path|
+	o.on("-v", "--verify [path]", String, "Verify a given path based on a previously saved fingerprint.") do |path|
 		OPTIONS[:mode] = :verify
-		OPTIONS[:root] = path
+		OPTIONS[:root] = path if path
 	end
 	
-	o.on("-n name", String, "Specify the name of the fingerprint file (default #{OPTIONS[:name]}).") do |name|
+	o.on("-n name", String, "Specify the name of the fingerprint file.", "Default: #{OPTIONS[:name]}") do |name|
 		OPTIONS[:name] = name
 	end
 	
@@ -74,18 +76,35 @@ ARGV.options do |o|
 	o.on("--verbose", "Verbose output, include additional details in the file transcript.") do
 		OPTIONS[:verbose] = true
 	end
+	
+	o.on("--progress", "Print percentage progress to standard error.") do
+		OPTIONS[:progress] = true
+	end
 
+	o.separator ""
+	
+	o.on("-x", "Include additional extended information about files and directories.") do
+		OPTIONS[:extended] = true
+	end
+	
+	o.on("-s [checksum1,checksum2]", "Provide a list of the checksum algorithms to use.", "Available: #{Fingerprint::CHECKSUMS.keys.join(', ')}; Default: #{OPTIONS[:checksums].join(', ')}") do |checksums|
+		OPTIONS[:checksums] = checksums.split(/[\s,]+/)
+	end
+	
 	o.separator ""
 	o.separator "Help and Copyright information:"
 
-	o.on_tail("--copy", "Display copyright information") {
-		$stderr.puts "#{script_name} v#{Fingerprint::VERSION::STRING}. Copyright (c) 2011 Samuel Williams. Released under the MIT license."
+	o.on_tail("--copy", "Display copyright and warranty information") do
+		$stderr.puts "#{script_name} v#{Fingerprint::VERSION::STRING}. Copyright (c) 2011 Samuel Williams."
+		$stderr.puts "This software is released under the MIT license and comes with ABSOLUTELY NO WARRANTY."
 		$stderr.puts "See http://www.oriontransfer.co.nz/ for more information."
-
 		exit
-	}
+	end
 
-	o.on_tail("-h", "--help", "Show this help message.") { $stderr.puts o; exit }
+	o.on_tail("-h", "--help", "Show this help message.") do
+		$stderr.puts o
+		exit
+	end
 end.parse!
 
 unless File.directory? OPTIONS[:root]
@@ -93,6 +112,10 @@ unless File.directory? OPTIONS[:root]
 	exit(255)
 end
 
+if OPTIONS[:checksums].size == 0
+	OPTIONS[:checksums] = ['MD5', 'SHA2.256']
+end
+
 case (OPTIONS[:mode])
 	when :analyze
 		output_file = Pathname.new(OPTIONS[:root]) + OPTIONS[:name]
@@ -102,9 +125,8 @@ case (OPTIONS[:mode])
 			exit(2)
 		end
 		
-		options = {}
+		options = OPTIONS.dup
 		options[:excludes] = [OPTIONS[:name]]
-		options[:verbose] = true if OPTIONS[:verbose]
 		
 		File.open(output_file, "w") do |io|
 			options[:output] = io
@@ -121,13 +143,23 @@ case (OPTIONS[:mode])
 			exit(3)
 		end
 		
-		scanner = Fingerprint::Scanner.scan_paths([OPTIONS[:root]])
-		scanner.output.seek(0)
+		options = OPTIONS.dup
+		
+		master = Fingerprint::Recordset.new
 		
 		File.open(input_file, "r") do |io|
-			error_count += Fingerprint::Checker.check_files(io, scanner.output)
+			master.parse(io)
 		end
 		
+		if master.configuration
+			options.merge!(master.configuration.options)
+		end
+
+		scanner = Fingerprint::Scanner.new([OPTIONS[:root]], options)
+		copy = Fingerprint::SparseRecordset.new(scanner)
+
+		error_count += Fingerprint::Checker::verify(master, copy, options)
+		
 		if error_count == 0
 			$stderr.puts "Data verified, 0 errors found."
 			exit(0)
@@ -148,13 +180,13 @@ case (OPTIONS[:mode])
 				true
 			end
 		end
-		
-		options = {}
-		options[:verbose] = true if OPTIONS[:verbose]
-		options[:output] = OPTIONS[:output] || $stdout
-		
+
+		options = OPTIONS.dup
+
 		Fingerprint::Scanner.scan_paths(roots, options)
 	when :check
-		error_count = Fingerprint::Checker.check_files(ARGV[0], ARGV[1])
+		options = OPTIONS.dup
+		
+		error_count = Fingerprint::Checker.check_files(ARGV[0], ARGV[1], options)
 		exit(error_count > 0 ? 1 : 0)
 end

data/lib/fingerprint.rb

@@ -28,13 +28,13 @@ module Fingerprint
 		master = Scanner.new([master_path])
 		copy = Scanner.new([copy_path])
 		
-		master.scan
-		copy.scan
+		master_recordset = Recordset.new
+		copy_recordset = SparseRecordset.new(copy)
 		
-		master.output.seek(0)
-		copy.output.seek(0)
+		master.scan(master_recordset)
+		
+		checker = Checker.new(master_recordset, copy_recordset)
 		
-		checker = Checker.new(master.output, copy.output)
 		checker.check(&block)
 		
 		return checker

data/lib/fingerprint/checker.rb

@@ -18,7 +18,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'set'
+require 'fingerprint/record'
 
 module Fingerprint
 	# Given two fingerprints (master and copy) ensures that the copy has at least everything contained
@@ -35,81 +35,101 @@ module Fingerprint
 			@master = master
 			@copy = copy
 			
-			@mismatches = []
-			
 			@options = options
-			
-			@failures = []
 		end
 
+		attr :master
+		attr :copy
+
 		# Run the checking process.
 		def check (options = {}, &block)
-			@files = Set.new
-			@file_paths = {}
-			@file_hashes = {}
-
-			# Parse original fingerprint
-			@copy.each_line do |line|
-				# Skip comments
-				next if line.match(/^\s+#/)
-				
-				if line.chomp.match(/^([a-fA-F0-9]{32}): (.*)$/)
-					@files.add([$1, $2])
-
-					@file_paths[$2] = $1
-					@file_hashes[$1] ||= Set.new
-					@file_hashes[$1].add($2)
-				end
-			end
-
 			# For every file in the src, we check that it exists
 			# in the destination:
-			@master.each_line do |line|
-				# Skip comments
-				next if line.match(/^\s+#/)
-				
-				if line.chomp.match(/^([a-fA-F0-9]{32}): (.*)$/)
-					unless @files.include?([$1, $2])
-						yield($1, $2) if block_given?
-						@failures << [$1, $2]
+			
+			total_count = @master.records.count
+			processed_size = 0
+			total_size = @master.records.inject(0) { |count, record| count + (record['file.size'] || 0).to_i }
+			
+			@master.records.each_with_index do |record, processed_count|
+				next if record.mode != :file
+
+				result, message = @copy.compare(record)
+				if result != :valid
+					yield record, result, message
+				elsif @options[:extended]
+					# Extended check compares other attributes such as user, group, file modes.
+					changes = record.diff(copy.paths[record.path])
+					
+					if changes.size > 0
+						yield record, :attribute_changed, "Attribute(s) #{changes.join(', ')} changed"
 					end
 				end
+				
+				if @options[:progress]
+					$stderr.puts "# Progress: File #{processed_count} / #{total_count} = #{sprintf('%0.2f%', processed_count.to_f / total_count.to_f * 100.0)}; Byte #{processed_size} / #{total_size} = #{sprintf('%0.2f%', processed_size.to_f / total_size.to_f * 100.0)}"
+
+					processed_size += (record['file.size'] || 0).to_i
+				end
 			end
 		end
 		
 		# A list of files which either did not exist in the copy, or had the wrong checksum.
 		attr :failures
-		
-		# An array of all files in the copy
-		attr :files
-		
-		# A hash of all files in copy +path => file hash+
-		attr :file_paths
-		
-		# A hash of all files in copy +file hash => [file1, file2, ...]+
-		attr :file_hashes
+
+		def self.check_files(master, copy, options = {}, &block)
+			# New API that takes two Recordsets...
+			
+			File.open(master) do |master_file|
+				File.open(copy) do |copy_file|
+					master_recordset = Recordset.new
+					master_recordset.parse(master_file)
+					
+					copy_recordset = Recordset.new
+					copy_recordset.parse(copy_file)
+
+					verify(master_recordset, copy_recordset, options, &block)
+				end
+			end
+		end
 
 		# Helper function to check two fingerprint files.
-		def self.check_files(master, copy, &block)
+		def self.verify(master, copy, options = {}, &block)
 			error_count = 0 
-			
-			master = File.open(master) unless master.respond_to? :read
-			copy = File.open(copy) unless copy.respond_to? :read
-			
-			checker = Checker.new(master, copy)
 
-			checker.check do |hash, path|
+			errors = options.delete(:recordset) || Recordset.new
+			if options[:output]
+				errors = RecordsetPrinter.new(errors, options[:output])
+			end
+
+			checker = Checker.new(master, copy, options)
+
+			checker.check do |record, result, message|
 				error_count += 1
+				copy = checker.copy.paths[record.path]
+
+				metadata = {
+					'error.code' => result,
+					'error.message' => message
+				}
 
-				if !checker.file_paths[path]
-					$stderr.puts "File #{path.dump} is missing!"
-				elsif checker.file_paths[path] != hash
-					$stderr.puts "File #{path.dump} is different!"
+				if copy
+					changes = record.diff(copy)
+
+					changes.each do |name|
+						metadata["changes.#{name}.old"] = record[name]
+						metadata["changes.#{name}.new"] = copy[name]
+					end
+
+					errors << Record.new(:warning, record.path, metadata)
 				else
-					$stderr.puts "Unknown error for path #{path.dump}"
+					errors << Record.new(:warning, record.path, metadata)
 				end
 			end
 
+			errors << Record.new(:summary, nil, {
+				'error.count' => error_count
+			})
+
 			return error_count
 		end
 

data/lib/fingerprint/record.rb

@@ -0,0 +1,262 @@
+# Copyright (c) 2011 Samuel G. D. Williams. <http://www.oriontransfer.co.nz>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'set'
+
+module Fingerprint
+
+	MODES = {
+		:configuration => 'C',
+		:file => 'F',
+		:directory => 'D',
+		:summary => 'S',
+		:warning => 'W',
+		:excluded => '#',
+	}
+
+	class Record
+		def initialize(mode, path, metadata)
+			@mode = mode
+			@path = path
+
+			@metadata = metadata
+			@keys = metadata.keys.grep(/^key\./)
+		end
+
+		attr :mode
+		attr :path
+		attr :metadata
+		attr :keys
+
+		def [](key)
+			@metadata[key]
+		end
+
+		def diff(other)
+			changes = []
+
+			all_keys = Set.new
+			all_keys += @metadata.keys + other.metadata.keys
+			# all_keys -= @keys + other.keys
+
+			all_keys.each do |key|
+				changes << key if @metadata[key].to_s != other.metadata[key].to_s
+			end
+
+			return changes
+		end
+		
+		def options
+			options = {}
+			
+			options[:extended] = true if @metadata['options.extended'] == 'true'
+			options[:checksum] = @metadata['options.checksums'].split(/[\s,]+/) if @metadata['options.checksums']
+			
+			return options
+		end
+		
+		def write(output)
+			output.puts "#{MODES[@mode]} #{@path}"
+			
+			return if @mode == :excluded
+			
+			@metadata.keys.sort.each do |key|
+				output.puts "\t#{key} #{@metadata[key]}"
+			end
+		end
+	end
+	
+	class Recordset
+		def initialize
+			@records = []
+			@paths = {}
+			@keys = {}
+
+			@configuration = nil
+
+			@callback = nil
+		end
+
+		attr :records
+		attr :paths
+		attr :keys
+
+		attr :configuration
+
+		def <<(record)
+			@records << record
+			if record.mode == :configuration
+				# What should we do if we get multiple configurations?
+				@configuration = record
+			else
+				@paths[record.path] = record
+				record.keys.each do |key, value|
+					@keys[key] = value
+				end
+			end
+		end
+
+		def lookup(path)
+			return @paths[path]
+		end
+
+		def find(record)
+			result = lookup(record.path)
+
+			return result if result
+
+			@record.keys.each do |key, value|
+				result = @keys[key][value]
+
+				return result if result
+			end
+
+			return nil
+		end
+
+		def compare(other)
+			main = lookup(other.path)
+
+			# Did we find a corresponding other at the same path?
+			if main
+				# Keep track of how many keys were checked..
+				checked = 0
+
+				# Are all the keys of the other record equivalent to the main record?
+				other.keys.each do |key|
+					if main[key]
+						checked += 1
+
+						# Is the key the same?
+						if main[key] != other[key]
+							return :keys_different, "Key #{key.gsub(/^key\./, '')} does not match"
+						end
+					end
+				end
+
+				# Are the records the same size? We put this check second because we do this as a last resort to
+				# ensure that the file hasn't been deliberately tampered with.
+				if main.metadata['size'] and other.metadata['size'] and main.metadata['size'] != other.metadata['size']
+					return :size_different, "File size differs"
+				end
+
+				if checked == 0
+					return :no_keys, "No valid keys to check"
+				else
+					# At least one key could be validated.
+					return :valid, "Valid"
+				end
+			else
+				return :not_found, "File not found"
+			end
+		end
+
+		def self.parse(input)
+			mode = nil
+			path = nil
+			metadata = nil
+
+			markers = {}
+			MODES.each do |key, value|
+				markers[value] = key
+			end
+
+			# Parse original fingerprint
+			input.each_line do |line|
+				# Skip comments and blank lines
+				next if line.match(/^\s*#/) || line.match(/^\s*$/)
+
+				if line.match(/^([A-Z])\s+(.*)$/)
+					if path
+						yield mode, path, metadata
+					end
+
+					mode = markers[$1] || :unknown
+
+					path = $2
+					metadata = {}
+				elsif line.match(/^\s+([a-zA-Z\.0-9]+)\s+(.*)$/)
+					metadata[$1] = $2
+				else
+					$stderr.puts "Unhandled line: #{line}"
+				end
+			end
+
+			if path
+				yield mode, path, metadata
+			end
+		end
+
+		def parse(input)
+			self.class.parse(input) do |mode, path, metadata|
+				self << Record.new(mode, path, metadata)
+			end
+		end
+		
+		def write(output)
+			@records.each do |record|
+				record.write(output)
+			end
+		end
+	end
+	
+	# This record set dynamically computes data from the disk as required.
+	class SparseRecordset < Recordset
+		def initialize(scanner)
+			super()
+			
+			@scanner = scanner
+		end
+		
+		def lookup(path)
+			if @paths.key?(path)
+				return @paths[path]
+			else
+				@paths[path] = @scanner.scan_path(path)
+			end
+		end
+	end
+	
+	class RecordsetWrapper
+		def initialize(recordset)
+			@recordset = recordset
+		end
+
+		def method_missing(name, *args, &block)
+			@recordset.send(name, *args, &block)
+		end
+
+		def respond_to?(name)
+			@recordset.respond_to?(name)
+		end
+	end
+	
+	class RecordsetPrinter < RecordsetWrapper
+		def initialize(recordset, output)
+			super(recordset)
+			@output = output
+		end
+
+		def <<(record)
+			record.write(@output)
+			@recordset << record
+		end
+	end
+end

data/lib/fingerprint/scanner.rb

@@ -20,10 +20,20 @@
 
 require 'stringio'
 require 'find'
-require 'digest'
+require 'etc'
+require 'digest/sha2'
 
 module Fingerprint
 
+	CHECKSUMS = {
+		'MD5' => lambda { Digest::MD5.new },
+		'SHA1' => lambda { Digest::SHA1.new },
+		'SHA2.256' => lambda { Digest::SHA2.new(256) },
+		'SHA2.512' => lambda { Digest::SHA2.new(512) },
+	}
+
+	DEFAULT_CHECKSUMS = ['MD5', 'SHA2.256']
+
 	# The scanner class can scan a set of directories and produce an index.
 	class Scanner
 		# Initialize the scanner to scan a given set of directories in order.
@@ -33,45 +43,100 @@ module Fingerprint
 			@roots = roots
 
 			@excludes = options[:excludes] || []
-			@output = options[:output] || StringIO.new
-			
 			@options = options
+
+			@digests = {}
+			
+			unless @options[:checksums] and @options[:checksums].size > 0
+				@options[:checksums] = DEFAULT_CHECKSUMS
+			end
+
+			@options[:checksums].each do |name|
+				@digests[name] = CHECKSUMS[name].call
+			end
+
+			@callback = nil
 		end
 
-		attr :output
+		attr :recordset
+		attr :digests
 
 		protected
-		
+
 		# Adds a header for a given path which is mainly version information.
-		def output_header(root)
-			@output.puts "\# Checksum generated by Fingerprint (#{Fingerprint::VERSION::STRING}) at #{Time.now.to_s}"
-			@output.puts "\# Root: #{root}"
-		end
-		
-		# Output a directory header.
-		def output_dir(path)
-			@output.puts ""
-			@output.puts((" " * 32) + "  #{path}")
+		def header_for(root)
+			Record.new(:configuration, File.expand_path(root), {
+				'options.extended' => @options[:extended] == true,
+				'options.checksums' => @options[:checksums].join(', '),
+				'summary.time.start' => Time.now,
+				'fingerprint.version' => Fingerprint::VERSION::STRING
+			})
 		end
-		
-		# Output a file and associated metadata.
-		def output_file(path)
-			d = Digest::MD5.new
 
-			File.open(path) do |f|
-				while buf = f.read(1024*1024*10)
-					d << buf
+		# This code won't handle multiple threads..
+		def digests_for(path)
+			@digests.each do |key, digest|
+				digest.reset
+			end
+
+			File.open(path, "rb") do |file|
+				buf = ""
+				while file.read(1024 * 1024 * 10, buf)
+					@digests.each do |key, digest|
+						digest << buf
+					end
 				end
 			end
 
-			@output.puts "#{d.hexdigest}: #{path}"
+			metadata = {}
+			
+			@digests.each do |key, digest|
+				metadata["key." + key] = digest.hexdigest
+			end
+			
+			return metadata
 		end
 
-		# Add information about excluded paths.
-		def output_excluded(path)
-			if @options[:verbose]
-				@output.puts '#'.ljust(32) + ": #{path}"
+		def metadata_for(type, path)
+			stat = File.stat(path)
+			metadata = {}
+
+			if type == :file
+				metadata['file.size'] = stat.size
+				digests = digests_for(path)
 			end
+
+			# Extended information
+			if @options[:extended]
+				metadata['posix.time.modified'] = File.mtime(path)
+
+				metadata['posix.mode'] = stat.mode.to_s(8)
+
+				metadata['posix.permissions.user.id'] = stat.uid
+				metadata['posix.permissions.user.name'] = Etc.getpwuid(stat.uid).name
+				metadata['posix.permissions.group.id'] = stat.gid
+				metadata['posix.permissions.group.name'] = Etc.getgrgid(stat.gid).name
+			end
+
+			return metadata
+		end
+		
+		# Output a directory header.
+		def directory_record_for(path)
+			Record.new(:directory, path, metadata_for(:directory, path))
+		end
+
+		# Output a file and associated metadata.
+		def file_record_for(path)
+			metadata = metadata_for(:file, path)
+			metadata.merge!(digests_for(path))
+			
+			Record.new(:file, path, metadata)
+		end
+
+		# Add information about excluded paths.
+		def excluded_record_for(path)
+			Record.new(:excluded, path)
 		end
 
 		public
@@ -87,50 +152,119 @@ module Fingerprint
 			return false
 		end
 
+		def valid_file?(path)
+			!(excluded?(path) || File.symlink?(path) || !File.file?(path) || !File.readable?(path))
+		end
+
+		def scan_path(path)
+			@roots.each do |root|
+				Dir.chdir(root) do
+					if valid_file?(path)
+						return file_record_for(path)
+					end
+				end
+			end
+			
+			return nil
+		end
+
 		# Run the scanning process.
-		def scan
+		def scan(recordset)
 			excluded_count = 0
-			checksummed_count = 0
+			processed_count = 0
+			processed_size = 0
 			directory_count = 0
+
+			total_count = 0
+			total_size = 0
+
+			# Estimate the number of files and amount of data to process..
+			if @options[:progress]
+				@roots.each do |root|
+					Dir.chdir(root) do
+						Find.find("./") do |path|
+							if File.directory?(path)
+								if excluded?(path)
+									Find.prune # Ignore this directory
+								end
+							else
+								# Skip anything that isn't a valid file (e.g. pipes, sockets, symlinks).
+								if valid_file?(path)
+									total_count += 1
+									total_size += File.size(path)
+								end
+							end
+						end
+					end
+				end
+			end
 			
 			@roots.each do |root|
 				Dir.chdir(root) do
-					output_header(root)
+					recordset << header_for(root)
+					
 					Find.find("./") do |path|
 						if File.directory?(path)
 							if excluded?(path)
 								excluded_count += 1
-								output_excluded(path)
+								
+								if @options[:verbose]
+									recordset << excluded_record_for(path)
+								end
+								
 								Find.prune # Ignore this directory
 							else
 								directory_count += 1
-								output_dir(path)
+								
+								recordset << directory_record_for(path)
 							end
 						else
 							# Skip anything that isn't a valid file (e.g. pipes, sockets, symlinks).
-							if excluded?(path) || File.symlink?(path) || !File.file?(path) || !File.readable?(path)
-								excluded_count += 1
-								output_excluded(path)
+							if valid_file?(path)
+								processed_count += 1
+								processed_size += File.size(path)
+
+								recordset << file_record_for(path)
 							else
-								checksummed_count += 1
-								output_file(path)
+								excluded_count += 1
+								
+								if @options[:verbose]
+									recordset << excluded_record_for(path)
+								end
 							end
 						end
+						
+						# Print out a progress summary if requested
+						if @options[:progress]
+							$stderr.puts "# Progress: File #{processed_count} / #{total_count} = #{sprintf('%0.2f%', processed_count.to_f / total_count.to_f * 100.0)}; Byte #{processed_size} / #{total_size} = #{sprintf('%0.2f%', processed_size.to_f / total_size.to_f * 100.0)}"
+						end
 					end
 				end
 			end
-			
+
 			# Output summary
-			@output.puts "\# Directories: #{directory_count} Files: #{checksummed_count} Excluded: #{excluded_count}"
+			recordset << Record.new(:summary, nil, {
+				'summary.directories' => directory_count,
+				'summary.files' => processed_count,
+				'summary.size' => processed_size,
+				'summary.excluded' => excluded_count,
+				'summary.time.end' => Time.now
+			})
+			
+			return recordset
 		end
 
 		# A helper function to scan a set of directories.
 		def self.scan_paths(paths, options = {})
+			if options[:output]
+				options[:recordset] = RecordsetPrinter.new(Recordset.new, options[:output])
+			end
+
 			scanner = Scanner.new(paths, options)
-			
-			scanner.scan
-			
-			return scanner
+
+			scanner.scan(options[:recordset])
+
+			return options[:recordset]
 		end
 	end
 end

data/lib/fingerprint/version.rb

@@ -22,8 +22,8 @@
 module Fingerprint
   module VERSION
     MAJOR = 1
-    MINOR = 2
-    TINY  = 4
+    MINOR = 3
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fingerprint
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 27
   prerelease: 
   segments: 
   - 1
-  - 2
-  - 4
-  version: 1.2.4
+  - 3
+  - 0
+  version: 1.3.0
 platform: ruby
 authors: 
 - Samuel Williams
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-09 00:00:00 Z
+date: 2011-08-18 00:00:00 Z
 dependencies: []
 
 description: 
@@ -29,6 +29,7 @@ extra_rdoc_files: []
 files: 
 - bin/fingerprint
 - lib/fingerprint/checker.rb
+- lib/fingerprint/record.rb
 - lib/fingerprint/scanner.rb
 - lib/fingerprint/version.rb
 - lib/fingerprint.rb