safeguard 0.0.2 → 0.0.3

data/.gitignore

@@ -1 +1,2 @@
 .safeguard/
+*.lock

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+gemspec
+
+{ acclaim: '~/projects/acclaim',
+  ribbon: '~/projects/ribbon',
+  rookie: '~/projects/rookie' }.each do |project, path|
+  path = File.expand_path path
+  gem project.to_s, path: path if Dir.exists? path
+end

data/Rakefile

@@ -1,44 +1,3 @@
-this_dir  = File.expand_path('..', __FILE__)
-gem_dir   = File.join this_dir, 'gem'
-spec_file = File.join this_dir, 'safeguard.gemspec'
+require 'rookie'
 
-spec = Gem::Specification.load spec_file
-
-task :mkdir do
-  FileUtils.mkdir_p gem_dir
-end
-
-task :gem => :mkdir do
-  gem_file = File.join this_dir, Gem::Builder.new(spec).build
-  FileUtils.mv gem_file, gem_dir
-end
-
-namespace :gem do
-
-  task :build => :gem
-
-  gem_file = File.join gem_dir, "#{spec.name}-#{spec.version}.gem"
-
-  task :push => :gem do
-    sh "gem push #{gem_file}"
-  end
-
-  task :install => :gem do
-    sh "gem install #{gem_file}"
-  end
-
-  task :uninstall do
-    sh "gem uninstall #{spec.name}"
-  end
-
-  task :clean do
-    FileUtils.rm_rf gem_dir
-  end
-
-end
-
-task :clean => 'gem:clean'
-
-task :setup => [ 'gem:install', :clean ]
-
-task :default => :setup
+Rookie::Tasks.new 'safeguard.gemspec'

data/bin/safeguard

@@ -1,7 +1,4 @@
 #!/usr/bin/env ruby
 require 'safeguard'
 
-puts 'No command given' or exit if ARGV.empty?
-
-command = ARGV.shift
-Safeguard.run(command, *ARGV)
+Safeguard::Command.run *ARGV

data/lib/safeguard/command/add.rb

@@ -1,29 +1,27 @@
 require 'safeguard/command'
+require 'safeguard/digest'
 
 module Safeguard
-  module Command
+  class Command
 
     # Adds files to a Repository.
-    module Add
+    class Add < Command
 
-      Command.register self
+      opt :functions, '--use', Symbol,
+                      "Algorithm used to calculate the file's checksum. " <<
+                      "Currently supported: #{Digest::SUPPORTED_ALGORITHMS.join(', ')}",
+                      arity: [1,0], on_multiple: :append
+
+      opt :force, '--force', 'Rehash files that are already in the repository'
 
       # For every argument, try to add it to the Repository in the current
       # directory.
-      def self.execute(*args)
-        repo = Repository.new Dir.pwd
-        count = 0
-        args.each do |filename|
-          begin
-            puts "Adding #{filename}..."
-            repo.track filename
-            # If an exception is raised, count will not be incremented.
-            count += 1
-          rescue => e
-            puts e.message
-          end
+      action do |options, args|
+        repo = Repository.new options.dir
+        repo.before_save do
+          repo.add_files! *args, :functions => options.functions,
+                                 :force => options.force?
         end
-        puts "Added #{count} files to repository."
       end
 
     end

data/lib/safeguard/command/hash.rb

@@ -2,17 +2,31 @@ require 'safeguard/command'
 require 'safeguard/digest'
 
 module Safeguard
-  module Command
+  class Command
 
-    # Outputs the SHA1 hash of files.
-    module Hash
+    # Outputs the checksum of files.
+    #
+    #   $ safeguard hash *.mp3
+    #
+    # The hash function can be specified with the --hash-function option. The
+    # default is SHA1, but MD5 and CRC32 are also supported.
+    #
+    #   $ safeguard --hash-function md5 hash *.mp3
+    class Hash < Command
 
-      Command.register self
+      opt :func, '--hash-function', '--hash-functions', Symbol,
+                 "Algorithm to use to calculate the file's checksum. " <<
+                 "Currently supported: #{Digest::SUPPORTED_ALGORITHMS.join(', ')}",
+                 default: :sha1, arity: [1,-1]
 
-      # For every argument, outputs its SHA1 sum if it exists as a file.
-      def self.execute(*args)
-        args.each do |filename|
-          puts "#{Digest.file filename} => #{filename}" if File.file? filename
+      # For every argument, outputs its checksum if it exists as a file.
+      action do |options, args|
+        hasher = Hasher.new *args, :functions => options.func
+        hasher.each do |file, hash_data|
+          puts "#{file}:"
+          hasher.functions.each do |function|
+            puts "\t#{function} => #{hash_data[function]}"
+          end
         end
       end
 

data/lib/safeguard/command/init.rb

@@ -3,20 +3,20 @@ require 'safeguard/repository'
 require 'fileutils'
 
 module Safeguard
-  module Command
+  class Command
 
     # Initializes a Repository in a given directory.
-    module Init
-
-      Command.register self
+    #
+    #   $ safeguard init .
+    class Init < Command
 
       # Initializes a Safeguard Repository in a directory, which is either the
       # current directory, if +args+ is empty, or the directory designated by
       # the last element in +args+.
-      def self.execute(*args)
-        args << Dir.pwd if args.empty?
-        dir = File.expand_path args.pop
+      action do |options, args|
+        dir = File.expand_path(args.pop || options.dir)
         repo = Repository.new(dir)
+        repo.create_directory!
         puts "Initialized safeguard repository in #{repo.dir}"
       end
 

data/lib/safeguard/command/verify.rb

@@ -1,33 +1,33 @@
 require 'safeguard/command'
 
 module Safeguard
-  module Command
+  class Command
 
     # Verifies the files present in a Repository.
-    module Verify
+    class Verify < Command
 
-      Command.register self
+      opt :functions, '--use', Symbol,
+                      "Algorithm used to calculate the file's checksum. " <<
+                      "Currently supported: #{Digest::SUPPORTED_ALGORITHMS.join(', ')}",
+                      arity: [1,0], on_multiple: :append
 
       # Verify the files passed as arguments using information from the
       # Repository in the current directory.
-      def self.execute(*args)
-        repo = Repository.new Dir.pwd
-        if args.empty?
-          repo.verify_all do |filename, result|
-            display_result filename, result
-          end
-        else
-          args.each do |filename|
-            result = repo.verify filename
-            display_result filename, result
+      action do |options, args|
+        repo = Repository.new options.dir
+        functions = options.functions
+        results = repo.verify_files *args, functions: functions
+        results.keys.each do |file|
+          puts "#{file}:"
+          results[file].keys.each do |function|
+            value = results[file][function]
+            value = "File not in repository" if value == :file_missing
+            value = "Hash not in repository" if value == :hash_missing
+            puts "\t#{function} => #{value}"
           end
         end
       end
 
-      def self.display_result(filename, result)
-        puts "#{filename} => #{result ? 'OK' : 'Mismatch'}"
-      end
-
     end
 
   end

data/lib/safeguard/command.rb

@@ -1,42 +1,25 @@
-module Safeguard
-
-  # Manages the commands that may be given to Safeguard.
-  module Command
-
-    instance_eval do
+require 'acclaim/command'
+require 'acclaim/version'
 
-      # Returns a hash that associates command modules by name.
-      def commands
-        @commands ||= {}
-      end
-
-      alias :all :commands
+module Safeguard
 
-      # Computes a name for the command and associates it with the command's
-      # module.
-      def register(command_module)
-        name = command_module.name.gsub(/^.*::/, '').downcase
-        commands[name] = command_module
-      end
+  # Main Safeguard command. Currently just invokes the init command.
+  #
+  #   $ safeguard .
+  class Command < Acclaim::Command
 
-      # Looks up a command by name and returns its module, raising an exception
-      # if there is no match.
-      def find(command_name)
-        name = command_name.to_s.strip.downcase
-        commands[name].tap do |command|
-          raise "unsupported command: #{name}" if command.nil?
-        end
-      end
+    help
+    version Acclaim::Version::STRING
 
-      # Attempts to find a command by name, and, if successful, invokes it with
-      # the given arguments.
-      def invoke(command_name, *args)
-        find(command_name).execute(*args)
-      end
+    opt :dir, '-D', '--dir', '--directory', 'Directory in which the repository is.',
+              default: Dir.pwd, arity: [1,0]
 
+    action do |options, args|
+      Init.execute options, args
     end
 
   end
+
 end
 
 require 'safeguard/command/add'

data/lib/safeguard/core_ext/file.rb

@@ -0,0 +1,23 @@
+module Safeguard
+  module CoreExt
+    module File
+
+      # Default size of chunks in bytes. A megabyte is equal to 2^20 bytes, or
+      # 1,048,576 bytes.
+      DEFAULT_CHUNK_SIZE = 2 ** 20
+
+      # Reads a file piece by piece, yielding every chunk until the end of the
+      # file. Will yield chunks of DEFAULT_CHUNK_SIZE bytes, unless specified.
+      def each_chunk(chunk_size = DEFAULT_CHUNK_SIZE)
+        # A chunk_size of zero will cause an infinite loop. It will keep reading
+        # 0 bytes, so the pointer will never change and the end of the file will
+        # never be reached.
+        bytes = case chunk_size when nil, 0 then nil else chunk_size.abs end
+        yield read bytes until eof?
+      end
+    end
+
+    ::File.send :include, Safeguard::CoreExt::File
+
+  end
+end

data/lib/safeguard/digest/crc32.rb

@@ -0,0 +1,46 @@
+require 'digest'
+require 'zlib'
+
+module Safeguard
+  module Digest
+
+    # Digest implementation of CRC32 using Zlib.
+    class CRC32 < ::Digest::Class
+
+      include ::Digest::Instance
+
+      INITIAL_VALUE = 0
+
+      attr_reader :crc32
+
+      def initialize
+        reset
+      end
+
+      def reset
+        @crc32 = INITIAL_VALUE
+      end
+
+      def update(str)
+        @crc32 = Zlib.crc32(str, crc32)
+        self
+      end
+
+      alias << update
+
+      def finish
+        [ crc32 ].pack 'N'
+      end
+
+      def digest_length
+        1
+      end
+
+      def block_length
+        1
+      end
+
+    end
+
+  end
+end

data/lib/safeguard/digest.rb

@@ -1,3 +1,5 @@
+require 'safeguard/core_ext/file'
+require 'safeguard/digest/crc32'
 require 'openssl'
 
 module Safeguard
@@ -5,9 +7,56 @@ module Safeguard
   # Encapsulates checksum computation for files using a set of hash functions.
   module Digest
 
-    # Compute the SHA1 sum of a file.
-    def self.file(filename)
-      OpenSSL::Digest::SHA1.file(filename).hexdigest
+    SUPPORTED_ALGORITHMS = %w(sha1 md5 crc32).map!(&:to_sym).freeze
+
+    # Digests a file using an +algorithm+.
+    #
+    # Algorithms are expected include the Digest::Instance module.
+    #
+    #   OpenSSL::Digest::SHA1.include? Digest::Instance
+    #   => true
+    def self.digest_with(algorithm, filename)
+      digest = algorithm.new
+      File.open(filename, 'rb') do |file|
+        file.each_chunk do |chunk|
+          digest << chunk
+        end
+      end
+      digest.hexdigest!
+    end
+
+    private_class_method :digest_with
+
+    # Computes the SHA1 sum of the given file.
+    def self.sha1(*args)
+      digest_with OpenSSL::Digest::SHA1, *args
+    end
+
+    # Computes the MD5 sum of the given file.
+    def self.md5(*args)
+      digest_with OpenSSL::Digest::MD5, *args
+    end
+
+    # Computes the CRC32 sum of the given file.
+    def self.crc32(*args)
+      # Read file in binary mode. Doesn't make any difference in *nix, but Ruby
+      # will attempt to convert line endings if the file is opened in text mode
+      # in other platforms.
+      digest_with Safeguard::Digest::CRC32, *args
+    end
+
+    # Digests a file using a hash function, which can be the symbol of any
+    # Digest module method that takes a file. Uses SHA1 by default.
+    #
+    #   Safeguard::Digest.file(file, :md5)
+    #
+    # Is equivalent to:
+    #
+    #   Safeguard::Digest.md5(file)
+    def self.file(file, hash_function = :sha1)
+      f = hash_function.to_sym
+      raise ArgumentError, "Unsupported hash function: #{f}" unless respond_to? f
+      send hash_function, file
     end
 
   end

data/lib/safeguard/hasher.rb

@@ -0,0 +1,60 @@
+require 'safeguard/digest'
+require 'ribbon'
+require 'ribbon/core_ext/array'
+
+module Safeguard
+
+  # Hashes a set of files.
+  class Hasher
+
+    # The files which will be hashed.
+    attr_accessor :files
+
+    # The hash functions to use.
+    attr_accessor :functions
+
+    # Initializes a new hasher with the given files. Last argument can be an
+    # options hash or ribbon which specifies the hash functions to use:
+    #
+    #   files = %w(file1 file2 fil3)
+    #   Hasher.new *files, :functions => :sha1
+    #   Hasher.new *files, :functions => [ :sha1, :md5, :crc32 ]
+    def initialize(*args)
+      ribbon = args.extract_options_as_ribbon!
+      funcs = ribbon.functions? do
+        raise ArgumentError, 'No hash functions specified'
+      end
+      self.functions = [*funcs]
+      self.files = args
+    end
+
+    # Calculates the hash of each file. Updates the cached hash results.
+    def hash_files!
+      results = Ribbon.new
+      files.each do |file|
+        functions.each do |function|
+          results[file][function] = Safeguard::Digest.file file, function
+        end
+      end
+      results = Ribbon[results]
+      results.wrap_all!
+      @results = results
+    end
+
+    # Returns the cached results containing the hashes calculated for each file.
+    #
+    # In order to force hash recalculation, call #hash_files!.
+    def results
+      @results ||= hash_files!
+    end
+
+    # Yields file => hash data pairs or returns an enumerator.
+    def each(&block)
+      Ribbon[results].each &block
+    end
+
+    include Enumerable
+
+  end
+
+end

data/lib/safeguard/repository/hash_table.rb

@@ -0,0 +1,54 @@
+require 'safeguard/digest'
+require 'ribbon'
+require 'ribbon/core_ext'
+require 'yaml'
+
+module Safeguard
+  class Repository
+
+    # Holds filename => checksum pairs.
+    class HashTable
+
+      # Initializes this hash table with the contents of the given Ribbon.
+      def initialize(ribbon = nil, &block)
+        merge! ribbon, &block if ribbon
+      end
+
+      # Saves the HashTable to a YAML file.
+      def save(filename)
+        File.open(filename, 'w') do |file|
+          file.puts ribbon.to_yaml
+        end
+      end
+
+      # Loads the HashTable from a YAML file.
+      def self.load(filename)
+        new Ribbon::Wrapper.from_yaml File.read(filename)
+      end
+
+      # Merges this hash table's data with the other's.
+      def merge!(other)
+        other = other.ribbon if other.is_a? HashTable
+        Ribbon.deep_merge! ribbon, other
+      end
+
+      # Looks up the checksum data for the given +filename+.
+      def [](filename)
+        ribbon[filename]
+      end
+
+      # Returns a list of files present in this hash table.
+      def files
+        ribbon.keys
+      end
+
+      # The underlying wrapped ribbon used to store filenames and their
+      # associated hashes.
+      def ribbon
+        @ribbon ||= Ribbon::Wrapper.new
+      end
+
+    end
+
+  end
+end

data/lib/safeguard/repository.rb

@@ -1,4 +1,9 @@
-require 'safeguard/hash_table'
+require 'safeguard/hasher'
+require 'safeguard/repository/hash_table'
+require 'safeguard/verifier'
+require 'fileutils'
+require 'ribbon'
+require 'ribbon/core_ext'
 
 module Safeguard
 
@@ -15,17 +20,19 @@ module Safeguard
     alias :dir :directory
 
     # Initializes a Safeguard repository in or from the given directory.
-    #
-    # If the given directory does not contain a repository directory, whose name
-    # is defined by the DIRECTORY_NAME constant, it will be created.
     def initialize(dir)
       self.directory = Repository.directory_in(dir)
+    end
+
+    # Creates a directory for this repository, if one doesn't exist. The
+    # directory will have the name defined in the DIRECTORY_NAME constant.
+    def create_directory!
       FileUtils.mkdir_p directory
     end
 
-    # Loads this repository's HashTable. Creates a new one if unable to do so.
+    # This repository's HashTable. Lazily loaded from disk.
     def hash_table
-      HashTable.load hash_table_file_name rescue HashTable.new
+      @table ||= load_hash_table!
     end
 
     # Returns the name of the HashTable file relative to this repository.
@@ -33,30 +40,46 @@ module Safeguard
       File.join directory, HASH_TABLE_FILE_NAME
     end
 
-    # Adds a file to this repository's HashTable, and saves it.
-    def track(filename)
-      table = hash_table_file_name
-      file = File.expand_path filename
-      hash_table.instance_eval do
-        add file
-        save table
-      end
+    # Saves this Repository's HashTable with the filename returned by
+    # #hash_table_file_name.
+    def save_hash_table
+      hash_table.save hash_table_file_name
+    end
+
+    # Calls the block and ensures that all data is persisted afterwards.
+    def before_save(&block)
+      if block.arity == 1 then block.call self else instance_eval &block end
+    ensure
+      save_hash_table
     end
 
-    # Verifies whether or not the file still matches the original version.
-    #
-    # An exception will be raised if the given file isn't in the repository.
-    def verify(filename)
-      hash_table.verify File.expand_path(filename)
+    # Calculates the checksum of the given files and stores the results. +args+
+    # will be used to instantiate a new Hasher.
+    def add_files!(*args)
+      ribbon = args.extract_ribbon!
+      hasher = Hasher.new *args, ribbon
+      hasher.files.delete_if do |file|
+        hash_table.files.include? file
+      end unless ribbon.force?
+      results = hasher.results
+      hash_table.merge! results
     end
 
-    # Verifies all files present in this repository, and returns a hash of
-    # results associating a filename with either +true+, when the file is the
-    # same as the original version, or +false+, when otherwise.
-    #
-    # If a block is given, the filename and the result will be yielded instead.
-    def verify_all(&block)
-      hash_table.verify_all &block
+    # Creates a Hasher for the files present in this repository.
+    def create_hasher_with(functions)
+      Hasher.new *hash_table.files, :functions => functions
+    end
+
+    # Creates a verifier using this repository's hash table.
+    def create_verifier_with(*args)
+      ribbon = args.extract_wrapped_ribbon!
+      Verifier.new *args, ribbon.merge!(hash_table: hash_table)
+    end
+
+    # Recalculates the checksum of the given files and compares them to the
+    # stored values. +args+ will be used to instantiate a new Verifier.
+    def verify_files(*args)
+      create_verifier_with(*args).results
     end
 
     # Returns the path to the repository relative to the given +dir+.
@@ -64,10 +87,27 @@ module Safeguard
       File.join File.expand_path(dir), DIRECTORY_NAME
     end
 
+    # Checks whether or not this repository's directory has been created and
+    # initialized.
+    def initialized?
+      File.directory? dir
+    end
+
     # Checks whether or not a repository has been created in the given +dir+.
     def self.initialized?(dir)
       File.directory? directory_in(dir)
     end
 
+    private
+
+    # Loads the hash table from file. Creates a new one if unable to do so.
+    def load_hash_table!
+      HashTable.load hash_table_file_name
+    rescue
+      # TODO: handle all error cases properly. This can overwrite a perfectly
+      #       good hash table for incredibly sily reasons.
+      HashTable.new
+    end
+
   end
 end

data/lib/safeguard/verifier.rb

@@ -0,0 +1,88 @@
+require 'safeguard/hasher'
+require 'safeguard/repository/hash_table'
+require 'ribbon'
+require 'ribbon/core_ext/array'
+
+module Safeguard
+
+  # Rehashes a set of files and compares the results to the stored hashes.
+  class Verifier
+
+    # The hasher used to calculate the checksum of the files.
+    attr_accessor :hasher
+
+    # Hash table to compare results against.
+    attr_accessor :hash_table
+
+    # Initializes a new verifier with the given files. Last argument can be an
+    # options hash or ribbon which specifies the hash table to verify against
+    # and the Hasher to use. If a hasher isn't specified, a new one will be
+    # created using the files and options given. If no files were given, the
+    # hash table's list of files will be used.
+    #
+    #   files  = %w(file1 file2 file3)
+    #   hasher = Hasher.new *files, :functions => :crc32
+    #   table  = hasher.results
+    #
+    #   Verifier.new :hasher => hasher, :hash_table => table
+    #   Verifier.new :functions => [ :crc32, :md5 ], :hash_table => table
+    #   Verifier.new *files, :functions => :crc32, :hash_table => table
+    def initialize(*args)
+      ribbon = args.extract_ribbon!
+      table = ribbon.hash_table? do
+        raise ArgumentError, 'No hash table to verify against'
+      end
+      table = table.ribbon if Repository::HashTable === table
+      self.hash_table = Ribbon[table]
+      hash_table.wrap_all!
+      args = hash_table.keys if args.empty?
+      self.hasher = ribbon.hasher? do
+        Hasher.new *args, ribbon
+      end
+    end
+
+    # Uses the hasher to recalculate the hashes of the files using the specified
+    # functions and compares the results with the data on the hash table.
+    #
+    # If a given file is not present in the hash table, the result of all
+    # comparisons will be the <tt>:file_missing</tt> symbol. If the value of a
+    # given hash for a given file is not present in the hash table, the result
+    # of the comparison will be the <tt>:hash_missing</tt> symbol.
+    def verify!
+      results = Ribbon.new
+      hasher.each do |file, hash_data|
+        hasher.functions.each do |function|
+          results[file][function] = if hash_table.has_key? file
+            if hash_table[file].has_key? function
+              hash_data[function] == hash_table[file][function]
+            else
+              :hash_missing
+            end
+          else
+            :file_missing
+          end
+        end
+      end
+      results = Ribbon[results]
+      results.wrap_all!
+      @results = results
+    end
+
+    # Returns the cached data containing the results of the comparison betweeb
+    # the recalculated hashes of the files with the data in the hash table.
+    #
+    # To force recomputation, call the #verify! method.
+    def results
+      @results ||= verify!
+    end
+
+    # Yields file => comparison data pairs, or returns an enumerator.
+    def each(&block)
+      Ribbon[results].each &block
+    end
+
+    include Enumerable
+
+  end
+
+end

data/lib/safeguard/version.rb

@@ -16,7 +16,7 @@ module Safeguard
     # Patch version.
     #
     # Increments denote changes in implementation.
-    PATCH = 2
+    PATCH = 3
 
     # Build version.
     #

data/lib/safeguard.rb

@@ -1,4 +1,9 @@
 require 'safeguard/command'
+require 'safeguard/digest'
+require 'safeguard/hasher'
+require 'safeguard/repository'
+require 'safeguard/verifier'
+require 'safeguard/version'
 
 # Safeguard module.
 module Safeguard

data/safeguard.gemspec

@@ -17,4 +17,9 @@ Gem::Specification.new('safeguard') do |gem|
   gem.files       = `git ls-files`.split "\n"
   gem.executables = `git ls-files -- bin/*`.split("\n").map &File.method(:basename)
 
+  gem.add_runtime_dependency 'acclaim'
+  gem.add_runtime_dependency 'ribbon'
+
+  gem.add_development_dependency 'rookie'
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: safeguard
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,41 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-15 00:00:00.000000000 Z
-dependencies: []
+date: 2012-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: acclaim
+  requirement: &6175680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *6175680
+- !ruby/object:Gem::Dependency
+  name: ribbon
+  requirement: &6174640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *6174640
+- !ruby/object:Gem::Dependency
+  name: rookie
+  requirement: &6174080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *6174080
 description: Hash-based file integrity verification utility
 email: matheus.a.m.moreira@gmail.com
 executables:
@@ -20,6 +53,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rvmrc
+- Gemfile
 - LICENSE.GPLv3
 - README.markdown
 - Rakefile
@@ -30,9 +64,13 @@ files:
 - lib/safeguard/command/hash.rb
 - lib/safeguard/command/init.rb
 - lib/safeguard/command/verify.rb
+- lib/safeguard/core_ext/file.rb
 - lib/safeguard/digest.rb
-- lib/safeguard/hash_table.rb
+- lib/safeguard/digest/crc32.rb
+- lib/safeguard/hasher.rb
 - lib/safeguard/repository.rb
+- lib/safeguard/repository/hash_table.rb
+- lib/safeguard/verifier.rb
 - lib/safeguard/version.rb
 - safeguard.gemspec
 homepage: https://github.com/matheusmoreira/safeguard
@@ -47,12 +85,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -397877248667330061
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -397877248667330061
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10

data/lib/safeguard/hash_table.rb

@@ -1,71 +0,0 @@
-require 'safeguard/digest'
-require 'yaml'
-
-module Safeguard
-
-  # Holds filename => checksum pairs.
-  class HashTable
-
-    # Initializes an empty HashTable.
-    def initialize
-      @table = {}
-    end
-
-    # Saves the HashTable to a YAML file.
-    def save(filename)
-      File.open("#{filename}.yaml", 'w') do |file|
-        file.puts to_yaml
-      end
-    end
-
-    # Loads the HashTable from a YAML file.
-    def self.load(filename)
-      YAML::load_file "#{filename}.yaml"
-    end
-
-    # Associates the given +filename+ to the computed checksum of the file it
-    # refers to.
-    def <<(filename)
-      @table[filename] = Digest.file filename
-    end
-
-    alias :add :<<
-
-    # Looks up the checksum for the given +filename+.
-    def [](filename)
-      @table[filename]
-    end
-
-    # Recalculates the hash and compares it to the original hash associated with
-    # the given filename.
-    #
-    # If a hash for the given file isn't stored in this table, an exception will
-    # be raised.
-    def verify(filename)
-      hash = @table[filename]
-      raise "File not in repository: #{filename}" unless hash
-      Digest.file(filename) == hash
-    end
-
-    # Verifies all files stored in this table and returns a hash of results
-    # associating a filename with either +true+, when the file's recalculated
-    # hash is equal to the hash stored in this table, or +false+, when
-    # otherwise.
-    #
-    # If a block is given, the filename and the result will be yielded instead.
-    def verify_all
-      files = @table.keys
-      if block_given?
-        files.each { |file| yield file, verify(file) }
-      else
-        {}.tap do |results|
-          files.each do |file|
-            results[file] = verify file
-          end
-        end
-      end
-    end
-
-  end
-
-end