fixi 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+*.swp
+.fixi
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in fixi.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/fixi

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'trollop'
+require 'fixi'
+
+name = ARGV.shift
+if name == "--help" || name == "-h" || name == "help"
+  name = ARGV.shift
+  if name.nil?
+    puts <<-EOS
+usage: fixi [--version] [--help] <command> [<options>] [path]
+
+All commands are scoped to the current directory or the given path, if specified.
+
+Commands:
+     add:   #{Fixi::Command::Add.synopsis}
+   check:   #{Fixi::Command::Check.synopsis}
+  commit:   #{Fixi::Command::Commit.synopsis}
+    info:   #{Fixi::Command::Info.synopsis}
+    init:   #{Fixi::Command::Init.synopsis}
+      ls:   #{Fixi::Command::Ls.synopsis}
+      rm:   #{Fixi::Command::Rm.synopsis}
+     sum:   #{Fixi::Command::Sum.synopsis}
+
+See 'fixi help <command>' for more information on a specific command.
+    EOS
+    exit 0
+  else
+    ARGV.insert(0, "--help")
+  end
+elsif name == "--version" || name == "-v"
+  puts "fixi version #{Fixi::VERSION}"
+  exit 0
+end
+
+command = Fixi::command name
+if command.nil?
+  puts "Error: No such command: #{name}"
+  exit 1
+end
+begin
+  command.execute ARGV
+rescue RuntimeError => msg
+  puts "Error: #{msg}"
+  exit 1
+#rescue => msg
+#  puts "Error: #{msg}"
+#  exit 1
+end

data/fixi.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "fixi/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fixi"
+  s.version     = Fixi::VERSION
+  s.authors     = ["Chris Wilper"]
+  s.email       = ["cwilper@gmail.com"]
+  s.homepage    = ""
+  s.summary     = "A fixity tracker utility"
+  s.description = "Keeps an index of checksums and lets you update and verify them"
+
+  s.rubyforge_project = "fixi"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+
+  s.add_runtime_dependency "trollop"
+end

data/lib/fixi/command/add.rb

@@ -0,0 +1,33 @@
+require 'trollop'
+require 'fixi/index'
+
+class Fixi::Command::Add
+  def self.synopsis
+    "Add new files to the index"
+  end
+
+  def self.details
+    "This command is scoped to the current directory or the given path,
+      if specified.".pack
+  end
+
+  def execute args
+    opts = Trollop::options args do
+      banner Fixi::Command.banner "add"
+      opt :absolute, "Show absolute paths. By default, paths are reported
+        relative to the index root.".pack
+      opt :dry_run, "Don't do anything; just report what would be done"
+    end
+    path = File.expand_path(args[0] || ".")
+    index = Fixi::Index.new(path)
+
+    index.find(path) do |abspath|
+      relpath = index.relpath(abspath)
+      unless index.contains?(relpath)
+        puts "A #{opts[:absolute] ? abspath : relpath}"
+        index.add(relpath) unless opts[:dry_run]
+      end
+    end
+
+  end
+end

data/lib/fixi/command/check.rb

@@ -0,0 +1,66 @@
+require 'trollop'
+
+class Fixi::Command::Check
+  def self.synopsis
+    "Verify the fixity of files in the index"
+  end
+
+  def self.details
+    "This command is scoped to the current directory or the given path,
+      if specified.".pack
+  end
+
+  def execute args
+    opts = Trollop::options args do
+      banner Fixi::Command.banner "check"
+      opt :absolute, "Show absolute paths. By default, paths are reported
+        relative to the index root.".pack
+      opt :shallow, "Do shallow comparisons when determining which files have
+        changed. If specified, only file sizes and mtimes will be used. By 
+        default, checksums will also be computed and compared if necessary.".pack
+      opt :verbose, "For modified files, show which attribute changed.
+        By default, only the path is shown.".pack
+    end
+    path = File.expand_path(args[0] || ".")
+    index = Fixi::Index.new(path)
+   
+    index.each(args[0]) do |hash|
+      relpath = hash['relpath']
+      abspath = index.rootpath + '/' + relpath
+      if index.file_in_scope(relpath)
+        if File.exists?(abspath)
+          size = File.size(abspath)
+          mtime = File.mtime(abspath).to_i
+          if size != hash['size']
+            detail = opts[:verbose] ? "size=#{size} " : ""
+            puts "M #{detail}#{opts[:absolute] ? abspath : relpath}"
+          elsif File.mtime(abspath).to_i != hash['mtime']
+            detail = opts[:verbose] ? "mtime=#{Time.at(mtime).utc.iso8601} " : ""
+            puts "M #{detail}#{opts[:absolute] ? abspath : relpath}"
+          elsif not opts[:shallow]
+            hexdigests = Fixi::hexdigests(Fixi::digests(index.algorithms), abspath)
+            i = 0
+            index.algorithms.split(',').each do |algorithm|
+              if hexdigests[i] != hash[algorithm]
+                detail = opts[:verbose] ? "#{algorithm}=#{hexdigests[i]} " : ""
+                puts "M #{detail}#{opts[:absolute] ? abspath : relpath}"
+              end
+              i += 1
+            end
+          end
+        else
+          puts "D #{opts[:absolute] ? abspath : relpath}"
+        end
+      else
+        puts "X #{opts[:absolute] ? abspath : relpath}"
+      end
+    end
+
+    index.find(path) do |abspath|
+      relpath = index.relpath(abspath)
+      unless index.contains?(relpath)
+        puts "A #{opts[:absolute] ? abspath : relpath}"
+      end
+    end
+  end
+end

data/lib/fixi/command/commit.rb

@@ -0,0 +1,62 @@
+require 'trollop'
+require 'find'
+require 'fixi/index'
+
+class Fixi::Command::Commit
+  def self.synopsis
+    "Commit modified files to the index"
+  end
+
+  def self.details
+    "This command is scoped to the current directory or the given path,
+      if specified.".pack
+  end
+
+  def execute args
+    opts = Trollop::options args do
+      banner Fixi::Command.banner "commit"
+      opt :absolute, "Show absolute paths. By default, paths are reported
+        relative to the index root.".pack
+      opt :dry_run, "Don't do anything; just report what would be done"
+      opt :shallow, "Do shallow comparisons when determining which files have
+        changed. If specified, only file sizes and mtimes will be used. By 
+        default, checksums will also be computed and compared if necessary.".pack
+      opt :verbose, "For modified files, show which attribute changed.
+        By default, only the path is shown.".pack
+    end
+    path = File.expand_path(args[0] || ".")
+    index = Fixi::Index.new(path)
+
+    index.each(args[0]) do |hash|
+      relpath = hash['relpath']
+      abspath = index.rootpath + '/' + relpath
+      if index.file_in_scope(relpath) && File.exists?(abspath)
+        size = File.size(abspath)
+        mtime = File.mtime(abspath).to_i
+        if size != hash['size']
+          detail = opts[:verbose] ? "size=#{size} " : ""
+          puts "M #{detail}#{opts[:absolute] ? abspath : relpath}"
+          index.update(relpath) unless opts[:dry_run]
+        elsif mtime != hash['mtime']
+          detail = opts[:verbose] ? "mtime=#{Time.at(mtime).utc.iso8601} " : ""
+          puts "M #{detail}#{opts[:absolute] ? abspath : relpath}"
+          index.update(relpath) unless opts[:dry_run]
+        elsif not opts[:shallow]
+          hexdigests = Fixi::hexdigests(Fixi::digests(index.algorithms), abspath)
+          i = 0
+          need_update = false
+          index.algorithms.split(',').each do |algorithm|
+            if not(need_update) && (hexdigests[i] != hash[algorithm])
+              need_update = true
+              detail = opts[:verbose] ? "#{algorithm}=#{hexdigests[i]} " : ""
+              puts "M #{detail}#{opts[:absolute] ? abspath : relpath}"
+            end
+            hash[algorithm] = hexdigests[i]
+            i += 1
+          end
+          index.update(relpath, hash) if need_update && not(opts[:dry_run])
+        end
+      end
+    end
+  end
+end

data/lib/fixi/command/info.rb

@@ -0,0 +1,20 @@
+require 'trollop'
+require 'fixi/index'
+
+class Fixi::Command::Info
+  def self.synopsis
+    "Display a summary of the index"
+  end
+
+  def self.details
+    "This command is scoped to the current directory or the given path,
+      if specified.".pack
+  end
+
+  def execute args
+    opts = Trollop::options args do
+      banner Fixi::Command::banner "info"
+    end
+    Fixi::Index.new(args[0]).describe
+  end
+end

data/lib/fixi/command/init.rb

@@ -0,0 +1,24 @@
+require 'trollop'
+require 'fixi/index'
+
+class Fixi::Command::Init
+  def self.synopsis
+    "Create a new, empty index"
+  end
+
+  def self.details
+    "This command is scoped to the current directory or the given path,
+      if specified.".pack
+  end
+
+  def execute args
+    opts = Trollop::options args do
+      banner Fixi::Command::banner "init"
+      opt :algorithms, "Checksum algorithm(s) to use for the index. This is
+        a comma-separated list, which may include md5, sha1, sha256, sha384, and
+        sha512.".pack, :default => "sha256", :short => 'l'
+    end
+    index = Fixi::Index.new(args[0], true, opts[:algorithms])
+    puts "Initialized empty index at #{index.dotpath}"
+  end
+end

data/lib/fixi/command/ls.rb

@@ -0,0 +1,70 @@
+require 'time'
+require 'trollop'
+
+class Fixi::Command::Ls
+  def self.synopsis
+    "List contents of the index"
+  end
+
+  def self.details
+    "This command is scoped to the current directory or the given path,
+      if specified.".pack
+  end
+
+  def execute args
+    opts = Trollop::options args do
+      banner Fixi::Command.banner "ls"
+      opt :absolute, "Show absolute paths. By default, paths are reported
+        relative to the index root.".pack
+      opt :json, "Like --verbose, but outputs the result as a json array."
+      opt :md5, "Restrict list to files with the given md5 checksum",
+        :type => :string, :short => :none
+      opt :sha1, "Restrict list to files with the given sha1 checksum",
+        :type => :string, :short => :none
+      opt :sha256, "Restrict list to files with the given sha256 checksum",
+        :type => :string, :short => :none
+      opt :sha384, "Restrict list to files with the given sha384 checksum",
+        :type => :string, :short => :none
+      opt :sha512, "Restrict list to files with the given sha512 checksum",
+        :type => :string, :short => :none
+      opt :verbose, "Include all information known about each file. By default,
+        only paths will be listed.".pack
+    end
+    index = Fixi::Index.new(args[0])
+    if opts[:json]
+      print "["
+    end
+    i = 0
+    index.each(args[0], opts) do |hash|
+      path = hash['relpath']
+      path = index.rootpath + '/' + path if opts[:absolute]
+      if opts[:verbose]
+        print "size=#{hash['size']},mtime=#{Time.at(hash['mtime']).utc.iso8601}"
+        print ",md5=#{hash['md5']}" if hash['md5']
+        print ",sha1=#{hash['sha1']}" if hash['sha1']
+        print ",sha256=#{hash['sha256']}" if hash['sha256']
+        print ",sha384=#{hash['sha384']}" if hash['sha384']
+        print ",sha512=#{hash['sha512']}" if hash['sha512']
+        puts " #{path}"
+      elsif opts[:json]
+        print "," if i > 0
+        puts "\n  { path: \"#{path}\","
+        puts "    size: \"#{hash['size']}\","
+        print "    mtime: \"#{Time.at(hash['mtime']).utc.iso8601}\""
+        print ",\n    md5: \"#{hash['md5']}\"" if hash['md5']
+        print ",\n    sha1: \"#{hash['sha1']}\"" if hash['md5']
+        print ",\n    sha256: \"#{hash['sha256']}\"" if hash['sha256']
+        print ",\n    sha384: \"#{hash['sha384']}\"" if hash['sha384']
+        print ",\n    sha512: \"#{hash['sha512']}\"" if hash['sha512']
+        print " }"
+      else
+        puts path
+      end
+      i += 1
+    end
+    if opts[:json]
+      print "\n" if i > 0
+      puts "]"
+    end
+  end
+end

data/lib/fixi/command/rm.rb

@@ -0,0 +1,40 @@
+require 'trollop'
+require 'find'
+require 'fixi/index'
+
+class Fixi::Command::Rm
+  def self.synopsis
+    "Delete old files from the index"
+  end
+
+  def self.details
+    "This command is scoped to the current directory or the given path,
+      if specified.".pack
+  end
+
+  def execute args
+    opts = Trollop::options args do
+      banner Fixi::Command.banner "rm"
+      opt :absolute, "Show absolute paths. By default, paths are reported
+        relative to the index root.".pack
+      opt :dry_run, "Don't do anything; just report what would be done"
+    end
+    path = File.expand_path(args[0] || ".")
+    index = Fixi::Index.new(path)
+
+    index.each(args[0]) do |hash|
+      relpath = hash['relpath']
+      abspath = index.rootpath + '/' + relpath
+      if index.file_in_scope(relpath)
+        unless File.exists?(abspath)
+          puts "D #{opts[:absolute] ? abspath : relpath}"
+          index.delete relpath unless opts[:dry_run]
+        end
+      else
+        puts "X #{opts[:absolute] ? abspath : relpath}"
+        index.delete relpath unless opts[:dry_run]
+      end
+    end
+
+  end
+end

data/lib/fixi/command/sum.rb

@@ -0,0 +1,34 @@
+require 'trollop'
+require 'find'
+require 'fixi/index'
+
+class Fixi::Command::Sum
+  def self.synopsis
+    "Calculate checksum(s) of a file"
+  end
+
+  def self.details
+      "This command operates on files and does not require an index to exist."
+  end
+
+  def execute args
+    opts = Trollop::options args do
+      banner Fixi::Command.banner "sum"
+      opt :algorithms, "Checksum algorithm(s) to use. This is a comma-separated
+        list, which may include  md5, sha1, sha256, sha384, and sha512. At least
+        one must be specified.".pack, :short => 'l', :type => :string,
+        :required => true
+    end
+    unless args[0]
+      raise "Must specify a file."
+      exit 1
+    end
+    path = args[0]
+    unless File.exists?(path)
+      raise "No such file: #{path}"
+      exit 1
+    end
+    hexdigests = Fixi::hexdigests(Fixi::digests(opts[:algorithms]), path)
+    hexdigests.each { |hexdigest| puts "#{hexdigest}" }
+  end
+end

data/lib/fixi/command.rb

@@ -0,0 +1,10 @@
+module Fixi::Command
+  def self.banner(name)
+    "fixi-#{name}: #{const_get(name.capitalize).synopsis}\n\n" +
+      "usage: fixi #{name} [<options>] [path]\n\n" +
+      "#{const_get(name.capitalize).details}\n\n" +
+      "Options:"
+  end
+end
+
+Dir.glob(File.dirname(__FILE__) + '/command/*') {|file| require file}

data/lib/fixi/index.rb

@@ -0,0 +1,203 @@
+require 'sqlite3'
+
+class Fixi::Index
+  attr_reader :dotpath, :rootpath, :dbversion, :algorithms
+
+  def initialize(startpath, create=false, algorithms=nil)
+    startpath = File.expand_path(startpath || ".")
+    unless File.directory?(startpath)
+      raise "No such file or directory: #{startpath}" unless File.exist?(startpath)
+      startpath = File.dirname(startpath)
+    end
+    if create
+      Fixi::digests(algorithms)
+      @dotpath = File.join(startpath, ".fixi")
+      raise "Index already exists at #{@dotpath}" if Dir.exist? @dotpath
+      Dir.mkdir @dotpath
+      @db = SQLite3::Database.new(File.join(@dotpath, "fixi.db"))
+      @dbversion = 1
+      @algorithms = algorithms
+      ddl = <<-EOS
+        create table fixi (
+          dbversion text,
+          algorithms text
+        );
+        create table file (
+          relpath text primary key,
+          size integer not null,
+          mtime integer not null,
+          md5 text,
+          sha1 text,
+          sha256 text,
+          sha384 text,
+          sha512 text
+        );
+        insert into fixi (dbversion, algorithms)
+          values (#{@dbversion}, "#{@algorithms}");
+      EOS
+      @db.execute_batch ddl
+      open(File.join(@dotpath, "includes"), "w") { |f| f.puts ".*" }
+      open(File.join(@dotpath, "excludes"), "w") { |f| f.puts "^\\.fixi\\/" }
+    else
+      @dotpath = find_dotpath(startpath)
+      @db = SQLite3::Database.new(File.join(@dotpath, "fixi.db"))
+      @db.execute("select dbversion, algorithms from fixi") do |row|
+        @dbversion = row[0]
+        @algorithms = row[1]
+      end
+    end
+    @includes = load_patterns("includes")
+    @excludes = load_patterns("excludes")
+    @rootpath = File.expand_path(File.join(@dotpath, ".."))
+    @db.results_as_hash = true
+  end
+
+  # Traverse the given path within @rootdir and return all files
+  # of interest (those matching @includes and not matching @excludes)
+  def find(path)
+    Find.find(path) do |abspath|
+      relpath = relpath(abspath)
+      if relpath.length > 0
+        if matches_any?(relpath, @includes)
+          if matches_any?(relpath, @excludes)
+            Find.prune
+          else
+            yield abspath unless File.directory?(abspath)
+          end
+        else
+          Find.prune unless File.directory?(abspath)
+        end  
+      end
+    end
+  end
+
+  def file_in_scope(relpath)
+    return matches_any?(relpath, @includes) &&
+      not(matches_any?(relpath, @excludes))
+  end
+
+  def each(path=nil, attribs={}) 
+    sql = "select * from file"
+    conditions = []
+    if path && File.expand_path(path) != @rootpath
+      relpath = relpath(File.expand_path(path))
+      if File.directory?(path)
+        conditions << " relpath like '#{relpath}/%'"
+      else
+        conditions << " relpath = '#{relpath}'"
+      end
+    end
+    attribs.each do |name,value|
+      if value && (name == :size || name == :mtime ||
+          name == :md5 || name == :sha1 || name == :sha256 ||
+          name == :sha384 || name == :sha512)
+        c = "#{name} = "
+        c += value.is_a?(Numeric) ? "#{value}" : "'#{value}'"
+        conditions << c
+      end
+    end
+    unless conditions.size == 0
+      sql += " where"
+      conditions.each do |c|
+        sql += " and" unless c == conditions.first
+        sql += " #{c}"
+      end
+    end
+    @db.execute(sql) do |hash|
+      yield hash
+    end
+  end
+
+  def size
+    @db.get_first_value("select count(*) from file")
+  end
+
+  def contains?(relpath)
+    @db.get_first_value("select count(*) from file where relpath = ?", relpath) > 0
+  end
+
+  def relpath(abspath)
+    return "" if abspath == @rootpath
+    abspath.slice(@rootpath.length + 1..-1)
+  end
+
+  def update(relpath, hash=nil)
+    abspath = File.join(@rootpath, relpath) 
+    unless hash
+      hash = Hash.new
+      hash['size'] = File.size(abspath)
+      hash['mtime'] = File.mtime(abspath).to_i
+      hexdigests = Fixi::hexdigests(Fixi::digests(@algorithms), abspath)
+      i = 0
+      @algorithms.split(',').each do |algorithm|
+        hash[algorithm] = hexdigests[i]
+      end
+    end
+    sql = "update file set size = #{hash['size']}, mtime = #{hash['mtime']}"
+    @algorithms.split(',').each do |algorithm|
+      sql += ", #{algorithm} = '#{hash[algorithm]}'"
+    end 
+    sql += " where relpath = ?" 
+    @db.execute(sql, relpath)
+  end
+
+  def add(relpath)
+    abspath = File.join(@rootpath, relpath)
+    sql = "insert into file (relpath, size, mtime, "
+    sql += @algorithms
+    sql += ") values (:relpath, :size, :mtime, "
+    values = Hash.new
+    values[:relpath] = relpath
+    values[:size] = File.size abspath
+    values[:mtime] = File.mtime(abspath).to_i
+    hexdigests = Fixi::hexdigests(Fixi::digests(@algorithms), abspath)
+    i = 0
+    @algorithms.split(",").each do |alg|
+      sql += ", " if i > 0
+      sql += "'" + hexdigests[i] + "'"
+      i += 1
+    end
+    sql += ")"
+    @db.execute(sql, values)
+  end
+
+  def delete(relpath)
+    @db.execute("delete from file where relpath = ?", relpath)
+  end
+
+  def describe
+    puts "#{size} files indexed at #{@dotpath}"
+    puts "Using checksum algorithm(s) [#{@algorithms}]"
+    puts "Fixi database version #{dbversion}"
+  end
+
+  private
+
+  def load_patterns(name)
+    result = []
+    f = File.join(@dotpath, name)
+    if File.exists? f
+      File.foreach(f) do |line|
+        line = line.chomp
+        result << Regexp.new(line) if line.length > 0
+      end
+    end
+    result
+  end
+
+  def matches_any?(path, patterns)
+    patterns.each do |pattern|
+      return true if pattern.match(path)
+    end
+    return false
+  end
+
+  # Return the first .fixi directory we find while traversing up the tree
+  def find_dotpath(path, startpath=path)
+    dotpath = File.join(path, ".fixi")
+    return dotpath if Dir.exist?(dotpath)
+    parent = File.dirname(path)
+    return find_dotpath(parent, startpath) unless parent == path
+    raise "No index at #{startpath} or any parent"
+  end
+end

data/lib/fixi/patch/string_pack.rb

@@ -0,0 +1,5 @@
+class String
+  def pack
+    self.gsub(/\s+/, ' ').strip
+  end
+end

data/lib/fixi/version.rb

@@ -0,0 +1,3 @@
+module Fixi
+  VERSION = "0.0.1"
+end

data/lib/fixi.rb

@@ -0,0 +1,42 @@
+require "digest"
+require "fixi/version"
+require "fixi/patch/string_pack"
+require "fixi/command"
+
+module Fixi
+  # Get an instance of the command with the given name
+  def self.command(name)
+    return nil unless Command.const_defined? name.capitalize
+    Command.const_get(name.capitalize).new
+  end
+
+  # Validate the given comma-separated list of checksum algorithms
+  # and return and array of matching Digest implementations
+  def self.digests(checksums)
+    digests = []
+    checksums.split(",").each do |checksum|
+      begin
+        digests << Digest(checksum.upcase).new
+      rescue LoadError
+        raise "No such algorithm: #{checksum}"
+      end
+    end
+    digests
+  end
+
+  # Read the file once while computing any number of digests
+  def self.hexdigests(digests, file)
+    File.open(file, "rb") {|f|
+      buf = ""
+      while f.read(16384, buf)
+        digests.each {|digest| digest.update buf}
+      end
+    }
+    hds = []
+    digests.each {|digest|
+      hd = digest.hexdigest
+      hds << hd
+    }
+    hds
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: fixi
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Chris Wilper
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-08 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: trollop
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Keeps an index of checksums and lets you update and verify them
+email: 
+- cwilper@gmail.com
+executables: 
+- fixi
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- bin/fixi
+- fixi.gemspec
+- lib/fixi.rb
+- lib/fixi/command.rb
+- lib/fixi/command/add.rb
+- lib/fixi/command/check.rb
+- lib/fixi/command/commit.rb
+- lib/fixi/command/info.rb
+- lib/fixi/command/init.rb
+- lib/fixi/command/ls.rb
+- lib/fixi/command/rm.rb
+- lib/fixi/command/sum.rb
+- lib/fixi/index.rb
+- lib/fixi/patch/string_pack.rb
+- lib/fixi/version.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: fixi
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: A fixity tracker utility
+test_files: []
+