cwninja-active_record_lint 0.0.3

data/README.markdown

@@ -0,0 +1,23 @@
+ActiveRecord::Lint
+================
+
+A library to support the automatic checking for the doing of stupid things 
+with ActiveRecord.
+
+AR::Lint is not big, nor is it clever, nor is it that well written.
+It makes recommendations based upon what I have found to be good practice, with
+only anecdotal evidence to support it.
+
+This is *not* a substitute for a DB admin, nor is it a substitute for knoledge.
+
+Your mileage may vary, remember to check your tire pressure.
+
+Usage
+-----
+
+You can check a typical rails application by executing:
+> $ arlint path/to/rails/app
+
+Support for automated tests and making it work with rake is something I could do to get around to.
+
+Copyright (c) 2008 Tom Lea, released under the MIT Licence

data/Rakefile

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'date'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+namespace :test do
+  desc 'Functional tests.'
+  Rake::TestTask.new(:functional) do |t|
+    t.libs << 'lib'
+    t.pattern = 'test/functional/*_test.rb'
+    t.verbose = true
+  end
+  desc 'Unit tests.'
+  Rake::TestTask.new(:unit) do |t|
+    t.libs << 'lib'
+    t.pattern = 'test/unit/*_test.rb'
+    t.verbose = true
+  end
+end
+
+task :test => ["test:functional", "test:unit"]
+
+spec = Gem::Specification.new do |s|
+  s.name        = %q{active_record_lint}
+  s.version     = "0.0.3"
+  s.summary     = %q{Rails tool to find foreign keys without indexes and other common issues.}
+  s.description = %q{A library to support the automatic checking for the doing of stupid things with ActiveRecord.}
+
+  s.executables = ["arlint"]
+  s.files        = FileList['[A-Z]*', 'lib/**/*.rb', 'test/**/*.rb']
+  s.require_path = 'lib'
+  s.test_files   = Dir[*['test/**/*_test.rb']]
+  s.homepage = "http://github.com/cwninja/active_record_lint"
+
+  s.has_rdoc         = true
+  s.extra_rdoc_files = ["README.markdown"]
+  s.rdoc_options = ['--line-numbers', '--inline-source', "--main", "README.markdown"]
+
+  s.authors = ["Tom Lea"]
+  s.email   = %q{commits@tomlea.co.uk}
+
+  s.platform = Gem::Platform::RUBY
+end
+
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+desc "Clean files generated by rake tasks"
+task :clobber => [:clobber_rdoc, :clobber_package]
+
+desc "Generate a gemspec file"
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+end
+

data/bin/arlint

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+path = ARGV.last || Dir.pwd
+
+boot_path = File.join(path, 'config', 'boot.rb')
+environment_path = File.join(path, 'config', 'environment.rb')
+
+unless(File.exists?(boot_path) and File.exists?(environment_path))
+  puts "Usage: #{$0} path/to/rails/root"
+  exit(1)
+end
+
+require boot_path
+require environment_path
+require 'active_record_lint'
+
+ActiveRecord::Lint.load_models(path)
+
+scanner = ActiveRecord::Lint::Scanner.new()
+reporter = ActiveRecord::Lint::Reporter.new(scanner)
+
+puts reporter

data/lib/active_record/lint.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'active_record'
+
+module ActiveRecord::Lint
+  def load_models(rails_root)
+    pattern = File.join(rails_root, "app", "models", "*.rb")
+    Dir.glob(pattern){|file|
+      load( file )
+    }
+  end
+  
+  def unload_models
+    models = ActiveRecord::Base.send :class_variable_get, :@@subclasses
+    models = models.keys - [ActiveRecord::Base]
+    models.map(&:name).each do |name|
+      Object.send :remove_const, name unless name.nil? or name.empty?
+    end
+    ActiveRecord::Base.send :class_variable_set, :@@subclasses, {}
+  end
+  
+  def missing_indexes(options = {})
+    load_models(options[:rails_root] || RAILS_ROOT)
+    Scanner.new(options[:connection] || ActiveRecord::Base.connection).missing_indexes
+  end
+  
+  extend self
+end
+
+
+Dir.glob(File.join(File.dirname(__FILE__), "lint", "*.rb")) do |file|
+  require file
+end

data/lib/active_record/lint/memoize.rb

@@ -0,0 +1,28 @@
+unless defined? Memoize
+  module Memoize
+
+    def self.included(other)
+      other.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      def memoize(*methods)
+        methods.each do |method|
+          define_method "#{method}_with_memoize" do |*args|
+             memoize_store_for(method)[args] ||= send("#{method}_without_memoize", *args)
+          end
+
+          alias_method_chain method, :memoize          
+        end
+      end
+    end
+
+    def memoize_store_for(method)
+      unless store = instance_variable_get("@_#{method}_memoized")
+        instance_variable_set("@_#{method}_memoized", store = {})
+      end
+      store
+    end
+  end
+
+end

data/lib/active_record/lint/pairs.rb

@@ -0,0 +1,53 @@
+module ActiveRecord::Lint
+  class Pair
+    include Comparable
+    attr_accessor :a, :b
+    
+    def initialize(a, b)
+      @a,@b=a,b
+    end
+    
+    def <=>(other)
+      (a <=> other.a).zero? ? (b <=> other.b) : (a <=> other.a)
+    end
+    
+    def eql?(other)
+      (self <=> other) == 0
+    end
+    
+    def pair_name
+      @pair_name ||= self.class.name.split("::").last
+    end
+    
+    def inspect
+      "#{pair_name}[#{a.inspect}, #{b.inspect}]"
+    end
+
+    def hash
+      a.hash ^ b.hash
+    end
+    
+    def to_ary
+      [a,b]
+    end
+    
+    alias to_a to_ary
+
+    class << self
+      alias [] new
+    end    
+  end
+
+  class TableColumnPair < Pair
+    alias table  a
+    alias column b
+  end
+
+  class TableKeyPair < TableColumnPair
+    alias key   b
+  end
+
+  class TableIndexPair < TableColumnPair
+    alias index b
+  end
+end

data/lib/active_record/lint/reporter.rb

@@ -0,0 +1,89 @@
+require File.join(File.dirname(__FILE__), "pairs")
+
+module ActiveRecord::Lint
+  class MissingIndex < TableIndexPair
+    def to_s
+      "The foreign key '#{index}' is not indexed on '#{table}'."
+    end
+  end
+  
+  class MissingTable
+    include Comparable
+    attr_reader :table
+    
+    def initialize(table)
+      @table=table
+    end
+    
+    def <=> (other)
+      table <=> other.table
+    end
+
+    def to_s
+      "Expected the table '#{table}' to exist."
+    end
+  end
+
+  class MissingForeignKey < TableKeyPair
+    def to_s
+      "Missing foreign key '#{key}' on '#{table}'."
+    end
+  end
+
+
+  class Reporter
+    include Memoize
+    SUMMARY_NAMES = ["missing_indexes", "missing_tables", "missing_foreign_keys"]
+
+    def initialize(scanner)
+      @scanner = scanner
+    end
+    
+    def missing_indexes
+      @scanner.missing_indexes.map{|pair| MissingIndex[*pair.to_ary] }
+    end
+    memoize :missing_indexes
+    
+    def missing_tables
+      tables = @scanner.missing_tables.map{|table_issue| MissingTable.new(table_issue) }
+      if defined?(ActionController::Base) and ActionController::Base.session_store != :active_record_store
+        tables.reject!{|table| table.table}
+      end
+      tables
+    end
+    memoize :missing_tables
+    
+    def missing_foreign_keys
+      @scanner.missing_foreign_keys.map{|pair| MissingForeignKey[*pair.to_ary] }
+    end
+    memoize :missing_foreign_keys
+    
+    def issues
+      SUMMARY_NAMES.map{|name| send(name) }.sum
+    end
+
+
+    def to_s
+      lines = returning([]){|output|
+        SUMMARY_NAMES.each do |name|
+          issues = send(name)
+          unless issues.empty?
+            output << "== #{name} =="
+            issues.each do |issue|
+              output << "* #{issue}"
+            end
+          end
+        end
+      }
+      if lines.empty?
+        "No issues found"
+      else
+        lines.join("\n")
+      end
+    end
+
+    private
+    attr_writer *SUMMARY_NAMES
+  end
+end
+

data/lib/active_record/lint/scanner.rb

@@ -0,0 +1,61 @@
+class ActiveRecord::Lint::Scanner
+  include ActiveRecord::Lint
+  include Memoize
+  
+  def initialize(connection = nil)
+    @connection = connection || ActiveRecord::Base.connection
+  end
+  
+  def missing_indexes
+    foreign_keys - indexes
+  end
+  
+  def missing_tables
+    classes.map{|klass| klass.table_name } - @connection.tables
+  end
+  
+  def missing_foreign_keys
+    foreign_keys - columns
+  end
+  
+  def foreign_keys
+    returning [] do |foreign_keys|
+      classes.each do |klass|
+        table_name = klass.table_name
+        klass.reflect_on_all_associations(:belongs_to).map(&:primary_key_name).each do |foreign_key|
+          foreign_keys << TableColumnPair.new(table_name, foreign_key)
+        end
+      end
+    end.uniq
+  end
+  memoize :foreign_keys
+  
+  def columns
+    returning [] do |columns|
+      @connection.tables.each do |table|
+        @connection.columns(table).each do |column|
+          columns << TableColumnPair.new(table, column.name)
+        end
+      end
+    end.uniq
+  end
+  memoize :columns
+  
+  def indexes
+    returning [] do |indexes|
+      @connection.tables.each do |table|
+        column_sets = @connection.indexes(table).map(&:columns)
+        column_sets.select{|col| col.size == 1}.flatten.each do |index|
+          indexes << TableIndexPair.new(table, index)
+        end
+      end
+    end.uniq
+  end
+  memoize :indexes
+  
+  def classes
+    ActiveRecord::Base.send(:subclasses)
+  end
+  memoize :classes
+  
+end

data/lib/active_record_lint.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "active_record", "lint")

data/test/fixtures/criminals/app/models/crime.rb

@@ -0,0 +1,5 @@
+class Crime < ActiveRecord::Base
+  has_many :incidents
+  has_many :victims, :through => :incidents
+  has_many :criminals, :through => :incidents
+end

data/test/fixtures/criminals/app/models/criminal.rb

@@ -0,0 +1,5 @@
+class Criminal < ActiveRecord::Base
+  has_many :incidents
+  has_many :victims, :through => :incidents
+  has_many :crimes, :through => :incidents
+end

data/test/fixtures/criminals/app/models/incident.rb

@@ -0,0 +1,5 @@
+class Incident < ActiveRecord::Base
+  belongs_to :criminal
+  belongs_to :victim
+  belongs_to :crime
+end

data/test/fixtures/criminals/app/models/victim.rb

@@ -0,0 +1,3 @@
+class Victim < ActiveRecord::Base
+  has_many :incidents
+end

data/test/functional/missing_foreign_keys_test.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+class MissingForeignKeysFunctionalTest < Test::Unit::TestCase
+  include CriminalDatabase
+  include ActiveRecord::Lint
+  
+  def setup
+    @rails_root = File.join(File.dirname(__FILE__), "..", "fixtures", "criminals")
+    ActiveRecord::Lint::load_models(@rails_root)
+    super
+    @connection.remove_column :incidents, :criminal_id
+  end
+  
+  def test_should_not_error_because_we_are_missing_criminal_id
+    missing_indexes = ActiveRecord::Lint::Scanner.new(@connection).missing_indexes
+    
+    assert_array_equal [Pair["incidents", "criminal_id"], Pair["incidents", "crime_id"]], missing_indexes
+  end
+
+  def test_should_report_lack_of_criminal_id_on_incidents_table
+    missing_foreign_keys = ActiveRecord::Lint::Scanner.new(@connection).missing_foreign_keys
+    
+    assert_array_equal [Pair["incidents", "criminal_id"]], missing_foreign_keys
+  end
+  
+end

data/test/functional/missing_indexes_test.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+class MissingIndexesAssociationsFunctionalTest < Test::Unit::TestCase
+  include CriminalDatabase
+  Pair = ActiveRecord::Lint::Pair
+  def setup
+    ActiveRecord::Lint::unload_models
+    @rails_root = File.join(File.dirname(__FILE__), "..", "fixtures", "criminals")
+    super
+  end
+  
+  def test_should_know_we_need_an_index_on_victims
+    ActiveRecord::Lint::load_models(@rails_root)
+    
+    missing_indexes = ActiveRecord::Lint::Scanner.new(@connection).missing_indexes
+    
+    assert_array_equal [Pair["incidents", "criminal_id"], Pair["incidents", "crime_id"]], missing_indexes
+  end
+
+  def test_should_be_able_to_call_missing_indexes_on_module
+    missing_indexes = ActiveRecord::Lint.missing_indexes(:rails_root => @rails_root)
+    
+    assert_array_equal [Pair["incidents", "criminal_id"], Pair["incidents", "crime_id"]], missing_indexes
+  end
+  
+  def test_should_handle_inherited_models
+    ActiveRecord::Lint::load_models(@rails_root)    
+    
+    my_model = Class.new(Incident)
+    missing_indexes = ActiveRecord::Lint::Scanner.new(@connection).missing_indexes
+    
+    assert_array_equal [Pair["incidents", "criminal_id"], Pair["incidents", "crime_id"]], missing_indexes
+  end
+  
+end

data/test/functional/missing_tables_test.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+class MissingTablesFunctionalTest < Test::Unit::TestCase
+  include CriminalDatabase
+  Pair = ActiveRecord::Lint::Pair
+  
+  def setup
+    @rails_root = File.join(File.dirname(__FILE__), "..", "fixtures", "criminals")
+    ActiveRecord::Lint::load_models(@rails_root)
+    super
+    @connection.drop_table :criminals
+  end
+  
+  def test_should_not_error_because_we_have_no_criminals_table
+    missing_indexes = ActiveRecord::Lint::Scanner.new(@connection).missing_indexes
+    
+    assert_array_equal [Pair["incidents", "criminal_id"], Pair["incidents", "crime_id"]], missing_indexes
+  end
+
+  def test_should_report_lack_of_criminals_table
+    missing_tables = ActiveRecord::Lint::Scanner.new(@connection).missing_tables
+    
+    assert_array_equal ["criminals"], missing_tables
+  end
+  
+end

data/test/functional/reporter_test.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+class ReporterMissingIndexesFunctionalTest < Test::Unit::TestCase
+  include CriminalDatabase
+  Lint = ActiveRecord::Lint
+  Pair = Lint::Pair
+  
+  def setup
+    super
+    @rails_root = File.join(File.dirname(__FILE__), "..", "fixtures", "criminals")
+    Lint::load_models(@rails_root)
+  end
+  
+  def test_should_report_missing_indexes_on_incidents
+    scanner = Lint::Scanner.new(@connection)
+    reporter = Lint::Reporter.new(scanner)
+    
+    assert_array_includes Lint::MissingIndex["incidents", "crime_id"], Lint::MissingIndex["incidents", "criminal_id"], reporter.missing_indexes
+  end
+
+  def test_issues_should_report_missing_indexes_on_incidents
+    scanner = Lint::Scanner.new(@connection)
+    reporter = Lint::Reporter.new(scanner)
+    
+    assert_array_includes Lint::MissingIndex["incidents", "crime_id"], Lint::MissingIndex["incidents", "criminal_id"], reporter.issues
+  end
+  
+end
+
+
+class ReporterMissingTablesFunctionalTest < Test::Unit::TestCase
+  include CriminalDatabase
+  Lint = ActiveRecord::Lint
+  Pair = Lint::Pair
+  
+  def setup
+    super
+    @connection.drop_table :criminals
+    @rails_root = File.join(File.dirname(__FILE__), "..", "fixtures", "criminals")
+    Lint::load_models(@rails_root)
+  end
+  
+  def test_should_report_missing_table_criminals
+    scanner = Lint::Scanner.new(@connection)
+    reporter = Lint::Reporter.new(scanner)
+    
+    assert_array_includes Lint::MissingTable.new("criminals"), reporter.missing_tables
+  end
+
+  def test_issues_should_report_missing_table_criminals
+    scanner = Lint::Scanner.new(@connection)
+    reporter = Lint::Reporter.new(scanner)
+    
+    assert_array_includes Lint::MissingTable.new("criminals"), reporter.issues
+  end
+  
+end
+
+class ReporterMissingForeignKeysFunctionalTest < Test::Unit::TestCase
+  include CriminalDatabase
+  Lint = ActiveRecord::Lint
+  Pair = Lint::Pair
+  
+  def setup
+    super
+    @connection.remove_column :incidents, :criminal_id
+    @rails_root = File.join(File.dirname(__FILE__), "..", "fixtures", "criminals")
+    Lint::load_models(@rails_root)
+  end
+  
+  def test_should_report_missing_table_criminals
+    scanner = Lint::Scanner.new(@connection)
+    reporter = Lint::Reporter.new(scanner)
+    
+    assert_array_includes Lint::MissingForeignKey["incidents", "criminal_id"], reporter.missing_foreign_keys
+  end
+
+  def test_issues_should_report_missing_table_criminals
+    scanner = Lint::Scanner.new(@connection)
+    reporter = Lint::Reporter.new(scanner)
+    
+    assert_array_includes Lint::MissingForeignKey["incidents", "criminal_id"], reporter.issues
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,87 @@
+require 'test/unit'
+
+require File.join(File.dirname(__FILE__), "..", "lib", "active_record_lint")
+
+module CriminalDatabase
+  def self.included(other)    
+    other.with_temp_db do
+      create_table :crimes do |t|
+      end
+
+      create_table :criminals do |t|
+      end
+
+      create_table :incidents do |t|
+        t.references :criminal
+        t.references :victim
+        t.references :crime
+      end
+
+      add_index :incidents, :victim_id
+
+      create_table :victims do |t|
+      end
+    end
+  end
+end
+
+class Test::Unit::TestCase
+  def self.with_temp_db(&block)
+    include TempDB    
+    @schema = Proc.new(&block) if block_given?
+  end
+  
+  module TempDB 
+    DB_PATH = "/tmp/%s.sqlite3"
+  
+    def teardown_database!
+      File.delete(DB_PATH % [self.class.name])
+    end
+  
+    def setup_database!
+      ActiveRecord::Base.establish_connection(
+        :adapter => "sqlite3",
+        :database => (DB_PATH % [self.class.name])
+      )
+      ActiveRecord::Base.logger = Logger.new(File.open("/dev/null", "w"))
+      @connection = ActiveRecord::Base.connection
+    end
+  
+    def load_schema!(&block)
+      ActiveRecord::Schema.verbose = false
+      if block_given?
+        ActiveRecord::Schema.define(&block)
+      else
+        ActiveRecord::Schema.define(&self.class.class_eval{@schema})
+      end
+    end
+  
+    def teardown
+      teardown_database!
+    end
+  
+    def setup
+      setup_database!
+      load_schema!
+    end
+  end
+  
+  def assert_array_equal(expected, actual, *args)
+    assert_equal(expected.sort, actual.sort, *args)
+  end
+  
+  def assert_array_includes(*args)
+    message = "Expected <%s> to include <%s>"
+    expected = args.clone
+    actual = expected.pop
+    
+    if actual.is_a? String
+      message = actual
+      actual = expected.pop
+    end
+
+    expected.each do |el|
+      assert actual.include?(el), (message % [actual.inspect, el.inspect])
+    end
+  end
+end

data/test/unit/indexes_test.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+class IndexesUnitTest < Test::Unit::TestCase
+  include CriminalDatabase
+  include ActiveRecord::Lint
+  
+  def test_should_have_correct_indexes
+    scanner = Scanner.new(@connection)
+    assert_equal([Pair["incidents", "victim_id"]], scanner.indexes)
+  end
+  
+end

data/test/unit/model_scanning_test.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+class ModelScanningUnitTest < Test::Unit::TestCase
+  include CriminalDatabase
+  include ActiveRecord::Lint
+
+  def setup
+    ActiveRecord::Lint::unload_models
+    super
+  end
+  
+  def test_should_have_correct_indexes    
+    rails_root = File.join(File.dirname(__FILE__), "..", "fixtures", "criminals")
+    ActiveRecord::Lint::load_models(rails_root)
+    
+    scanner = ActiveRecord::Lint::Scanner.new
+    
+    expected = [
+      Pair["incidents", "victim_id"],
+      Pair["incidents", "criminal_id"],
+      Pair["incidents", "crime_id"]
+    ]
+    
+    assert_array_equal(expected, scanner.foreign_keys)
+  end
+  
+end

data/test/unit/pair_test.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+class PairUnitTest < Test::Unit::TestCase
+  include ActiveRecord::Lint
+  def test_comparison
+    assert_equal(Pair[1,2], Pair[1,2])
+    assert_equal(0, Pair[1,2] <=> Pair[1,2])
+    assert_equal(-1, Pair[0,2] <=> Pair[1,2])
+    assert_equal(1, Pair[2,2] <=> Pair[1,2])
+    assert_equal(-1, Pair[1,1] <=> Pair[1,2])
+    assert_equal(1, Pair[1,3] <=> Pair[1,2])
+    
+    assert_not_equal(Pair[1,2], Pair[1,3])
+    assert_not_equal(Pair[1,2], Pair[2,2])
+  end
+  
+  def test_subtraction_in_an_array
+    a1 = [Pair[1,2], Pair[2,2], Pair[1,1]]
+    a2 = [Pair[1,2], Pair[1,1]]
+    a3 = [Pair[2,2]]
+
+    assert_equal(a2, a1 - a3)
+    assert_equal(a3, a1 - a2)
+    assert_equal([], a1 - a2 - a3)
+  end
+  
+  def test_hashes
+    assert_equal(Pair[1,2].hash, Pair[1,2].hash)
+    assert_equal(Pair[2,2].hash, Pair[2,2].hash)
+    assert_not_equal(Pair[1,2].hash, Pair[1,1].hash)
+    assert_not_equal(Pair[2,1].hash, Pair[1,1].hash)
+  end
+  
+  def test_eql
+    assert(Pair[2,2].eql?(Pair[2,2]))
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: cwninja-active_record_lint
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Tom Lea
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-08 00:00:00 -08:00
+default_executable: arlint
+dependencies: []
+
+description: A library to support the automatic checking for the doing of stupid things with ActiveRecord.
+email: commits@tomlea.co.uk
+executables: 
+- arlint
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- Rakefile
+- README.markdown
+- lib/active_record/lint/memoize.rb
+- lib/active_record/lint/pairs.rb
+- lib/active_record/lint/reporter.rb
+- lib/active_record/lint/scanner.rb
+- lib/active_record/lint.rb
+- lib/active_record_lint.rb
+- test/fixtures/criminals/app/models/crime.rb
+- test/fixtures/criminals/app/models/criminal.rb
+- test/fixtures/criminals/app/models/incident.rb
+- test/fixtures/criminals/app/models/victim.rb
+- test/functional/missing_foreign_keys_test.rb
+- test/functional/missing_indexes_test.rb
+- test/functional/missing_tables_test.rb
+- test/functional/reporter_test.rb
+- test/test_helper.rb
+- test/unit/indexes_test.rb
+- test/unit/model_scanning_test.rb
+- test/unit/pair_test.rb
+- bin/arlint
+has_rdoc: true
+homepage: http://github.com/cwninja/active_record_lint
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README.markdown
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Rails tool to find foreign keys without indexes and other common issues.
+test_files: 
+- test/functional/missing_foreign_keys_test.rb
+- test/functional/missing_indexes_test.rb
+- test/functional/missing_tables_test.rb
+- test/functional/reporter_test.rb
+- test/unit/indexes_test.rb
+- test/unit/model_scanning_test.rb
+- test/unit/pair_test.rb