db_leftovers 0.2.0 → 0.3.0

data/README.html

@@ -0,0 +1,102 @@
+<h1>db_leftovers</h1>
+
+<p>db_leftovers lets you define indexes and foreign keys for your Rails app
+in one place using an easy-to-read DSL,
+then run a rake task to bring your database up-to-date.
+I wrote this because I didn't want indexes and foreign keys scattered throughout my migrations or buried in my <code>schema.rb</code>, and I wanted a command I could run to ensure that they matched across my development, test, staging, and production databases.
+This was particularly a problem for Heroku projects, because <code>db:push</code> and <code>db:pull</code> do not transfer your foreign keys.
+But now that it's written, I'm finding it useful on non-Heroku projects as well.</p>
+
+<p>At present db_leftovers works only on PostgreSQL databases,
+but it could easily be extended to cover other RDBMSes.</p>
+
+<h2>Configuration File</h2>
+
+<p>db_leftovers reads a file named <code>config/db_leftovers.rb</code> to find out which indexes and foreign keys you want in your database. This file is a DSL implemented in Ruby, sort of like <code>config/routes.rb</code>. There are only a few methods:</p>
+
+<h3>index table_name, columns, [opts]</h3>
+
+<p>This ensures that you have an index on the given table and column(s). The <code>columns</code> parameter can be either a string or a list of strings. Opts is a hash with the following possible keys:</p>
+
+<ul>
+<li><p><code>:name</code> The name of the index. Defaults to <code>index_</code><em>table_name</em><code>_on_</code><em>column_names</em>, like the <code>add_index</code> method from Rails migrations.</p></li>
+<li><p><code>:unique</code> Set this to <code>true</code> if you'd like a unique index.</p></li>
+<li><p><code>:where</code> Accepts SQL to include in the <code>WHERE</code> part of the <code>CREATE INDEX</code> command, in case you want to limit the index to a subset of the table's rows.</p></li>
+</ul>
+
+<h4>Examples</h4>
+
+<pre><code>index :books, :author_id
+index :books, [:publisher_id, :published_at]
+index :books, :isbn, :unique =&gt; true
+</code></pre>
+
+<h3>foreign_key from_table, from_column, to_table, [to_column, [opts]]</h3>
+
+<p>This ensures that you have a foreign key relating the given tables and columns.
+All parameters are strings except <code>opts</code>, which is a hash.
+If you don't pass anything for <code>opts</code>, you can leave off the <code>to_column</code> parameter, and it will default to <code>:id</code>.
+These options are supported:</p>
+
+<ul>
+<li><code>:set_null</code> Indicates that the foreign key should be set to null if the referenced row is deleted.</li>
+<li><code>:cascade</code> Indicates that the referencing row should be deleted if the referenced row is deleted.</li>
+</ul>
+
+<p>These options are mutually exclusive. They should probably be consolidated into a single option like <code>:on_delete</code>.</p>
+
+<h4>Examples</h4>
+
+<pre><code>foreign_key :books, :author_id, :authors, :id
+foreign_key :books, :publisher_id, :publishers
+foreign_key :pages, :book_id, :books, :id, :cascade =&gt; true
+</code></pre>
+
+<h3>table table_name, &amp;block</h3>
+
+<p>The <code>table</code> call is just a convenience so you can group all a table's indexes and foreign keys together and not keep repeating the table name. You use it like this:</p>
+
+<pre><code>table :books do
+  index :author_id
+  foreign_key :publisher_id, :publishers
+end
+</code></pre>
+
+<p>You can repeat <code>table</code> calls for the same table several times if you like. This lets you put your indexes in one place and your foreign keys in another.</p>
+
+<h2>Running db_leftovers</h2>
+
+<p>db_leftovers comes with a Rake task named <code>db:leftovers</code>. So you can update your database to match your config file by saying this:</p>
+
+<pre><code>rake db:leftovers
+</code></pre>
+
+<h2>Known Issues</h2>
+
+<ul>
+<li><p>db_leftovers only supports PostgreSQL databases.
+If you want to add support for something else, just send me a pull request!</p></li>
+<li><p>db_leftovers will not notice if an index/foreign key definition changes.
+Right now it only checks for existence/non-existence.</p></li>
+<li><p>If your database is mostly up-to-date, then running the Rake task will spam
+you with messages about how this index and that foreign key already exist.
+These should be hidden by default and shown only if you request a higher
+verbosity.</p></li>
+</ul>
+
+<h2>Contributing to db_leftovers</h2>
+
+<ul>
+<li>Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet</li>
+<li>Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it</li>
+<li>Fork the project</li>
+<li>Start a feature/bugfix branch</li>
+<li>Commit and push until you are happy with your contribution</li>
+<li>Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.</li>
+<li>Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.</li>
+</ul>
+
+<h2>Copyright</h2>
+
+<p>Copyright (c) 2012 Paul A. Jungwirth. See LICENSE.txt for
+further details.</p>

data/README.md

@@ -0,0 +1,104 @@
+db\_leftovers
+=============
+
+db\_leftovers lets you define indexes and foreign keys for your Rails app
+in one place using an easy-to-read DSL,
+then run a rake task to bring your database up-to-date.
+I wrote this because I didn't want indexes and foreign keys scattered throughout my migrations or buried in my `schema.rb`, and I wanted a command I could run to ensure that they matched across my development, test, staging, and production databases.
+This was particularly a problem for Heroku projects, because `db:push` and `db:pull` do not transfer your foreign keys.
+But now that it's written, I'm finding it useful on non-Heroku projects as well.
+
+At present db\_leftovers works only on PostgreSQL databases,
+but it could easily be extended to cover other RDBMSes.
+
+Configuration File
+------------------
+
+db\_leftovers reads a file named `config/db_leftovers.rb` to find out which indexes and foreign keys you want in your database. This file is a DSL implemented in Ruby, sort of like `config/routes.rb`. There are only a few methods:
+
+### index table\_name, columns, [opts]
+
+This ensures that you have an index on the given table and column(s). The `columns` parameter can be either a string or a list of strings. Opts is a hash with the following possible keys:
+
+* `:name` The name of the index. Defaults to `index_`*table\_name*`_on_`*column\_names*, like the `add_index` method from Rails migrations.
+
+* `:unique` Set this to `true` if you'd like a unique index.
+
+* `:where` Accepts SQL to include in the `WHERE` part of the `CREATE INDEX` command, in case you want to limit the index to a subset of the table's rows.
+
+#### Examples
+
+    index :books, :author_id
+    index :books, [:publisher_id, :published_at]
+    index :books, :isbn, :unique => true
+
+### foreign\_key from\_table, from\_column, to\_table, [to\_column, [opts]]
+
+This ensures that you have a foreign key relating the given tables and columns.
+All parameters are strings except `opts`, which is a hash.
+If you don't pass anything for `opts`, you can leave off the `to_column` parameter, and it will default to `:id`.
+These options are supported:
+
+* `:set_null` Indicates that the foreign key should be set to null if the referenced row is deleted.
+* `:cascade` Indicates that the referencing row should be deleted if the referenced row is deleted.
+
+These options are mutually exclusive. They should probably be consolidated into a single option like `:on_delete`.
+
+#### Examples
+
+    foreign_key :books, :author_id, :authors, :id
+    foreign_key :books, :publisher_id, :publishers
+    foreign_key :pages, :book_id, :books, :id, :cascade => true
+
+### table table\_name, &block
+
+The `table` call is just a convenience so you can group all a table's indexes and foreign keys together and not keep repeating the table name. You use it like this:
+
+    table :books do
+      index :author_id
+      foreign_key :publisher_id, :publishers
+    end
+
+You can repeat `table` calls for the same table several times if you like. This lets you put your indexes in one place and your foreign keys in another.
+
+
+Running db\_leftovers
+---------------------
+
+db\_leftovers comes with a Rake task named `db:leftovers`. So you can update your database to match your config file by saying this:
+
+    rake db:leftovers
+
+
+Known Issues
+------------
+
+* db\_leftovers only supports PostgreSQL databases.
+  If you want to add support for something else, just send me a pull request!
+
+* db\_leftovers will not notice if an index/foreign key definition changes.
+  Right now it only checks for existence/non-existence.
+  
+* If your database is mostly up-to-date, then running the Rake task will spam
+  you with messages about how this index and that foreign key already exist.
+  These should be hidden by default and shown only if you request a higher
+  verbosity.
+ 
+
+Contributing to db\_leftovers
+-----------------------------
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+Copyright
+---------
+
+Copyright (c) 2012 Paul A. Jungwirth. See LICENSE.txt for
+further details.
+

data/TODO

@@ -0,0 +1,3 @@
+- Write the README
+- Support altering index and foreign keys if their definition changes
+- don't show "{index,fk} already exists" unless you set the verbosity higher

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/db_leftovers.gemspec

@@ -5,28 +5,35 @@
 
 Gem::Specification.new do |s|
   s.name = "db_leftovers"
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Paul A. Jungwirth"]
-  s.date = "2012-01-17"
+  s.date = "2012-01-20"
   s.description = "        Define indexes and foreign keys for your Rails app\n        in one place using an easy-to-read DSL,\n        then run a rake task to bring your database up-to-date.\n"
   s.email = "pj@illuminatedcomputing.com"
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc"
+    "README.html",
+    "README.md",
+    "TODO"
   ]
   s.files = [
     ".document",
     "Gemfile",
     "Gemfile.lock",
     "LICENSE.txt",
-    "README.rdoc",
+    "README.md",
     "Rakefile",
     "VERSION",
     "db_leftovers.gemspec",
     "lib/db_leftovers.rb",
+    "lib/db_leftovers/database_interface.rb",
+    "lib/db_leftovers/definition.rb",
     "lib/db_leftovers/dsl.rb",
+    "lib/db_leftovers/foreign_key.rb",
+    "lib/db_leftovers/index.rb",
+    "lib/db_leftovers/table_dsl.rb",
     "lib/tasks/leftovers.rake",
     "spec/db_leftovers_spec.rb",
     "spec/spec_helper.rb"

data/lib/db_leftovers/database_interface.rb

@@ -0,0 +1,88 @@
+module DBLeftovers
+
+  class DatabaseInterface
+
+    def lookup_all_indexes
+      ret = {}
+      sql = <<-EOQ
+          SELECT  n.nspname as "Schema", c.relname as "Name",
+                  CASE c.relkind WHEN 'r' THEN 'table' WHEN 'v' THEN 'view' WHEN 'i' THEN 'index' WHEN 'S' THEN 'sequence' WHEN 's' THEN 'special' END as "Type",
+                  u.usename as "Owner",
+                  c2.relname as "Table"
+          FROM    pg_catalog.pg_class c
+                  JOIN pg_catalog.pg_index i ON i.indexrelid = c.oid
+                  JOIN pg_catalog.pg_class c2 ON i.indrelid = c2.oid
+                  LEFT JOIN pg_catalog.pg_user u ON u.usesysid = c.relowner
+                  LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+          WHERE   c.relkind IN ('i','')
+          AND     n.nspname NOT IN ('pg_catalog', 'pg_toast')
+          AND     pg_catalog.pg_table_is_visible(c.oid)
+          AND     c.relname NOT LIKE '%_pkey'
+          AND     c2.relname NOT IN ('delayed_jobs', 'schema_migrations')
+          ORDER BY 1,2;
+      EOQ
+      ActiveRecord::Base.connection.select_rows(sql).each do |schema, index_name, object_type, owner, table_name|
+        ret[index_name] = table_name
+      end
+      return ret
+    end
+
+    def lookup_all_foreign_keys
+      ret = {}
+      sql = <<-EOQ
+          SELECT  t.constraint_name, t.table_name, k.column_name, t.constraint_type, c.table_name, c.column_name
+          FROM    information_schema.table_constraints t,
+                  information_schema.constraint_column_usage c,
+                  information_schema.key_column_usage k
+          WHERE   t.constraint_name = c.constraint_name
+          AND     k.constraint_name = c.constraint_name
+          AND     t.constraint_type = 'FOREIGN KEY'
+      EOQ
+      ActiveRecord::Base.connection.select_rows(sql).each do |constr_name, from_table, from_column, constr_type, to_table, to_column|
+        ret[constr_name] = ForeignKey.new(constr_name, from_table, from_column, to_table, to_column)
+      end
+      return ret
+    end
+
+    def execute_add_index(idx)
+      unique = idx.unique? ? 'UNIQUE' : ''
+      where = idx.where_clause.present? ? "WHERE #{idx.where_clause}" : ''
+
+      sql = <<-EOQ
+        CREATE #{unique} INDEX #{idx.index_name}
+        ON #{idx.table_name}
+        (#{idx.column_names.join(', ')})
+        #{where}
+      EOQ
+      execute_sql(sql)
+    end
+
+    def execute_drop_index(table_name, index_name)
+      sql = <<-EOQ
+          DROP INDEX #{index_name}
+      EOQ
+      execute_sql(sql)
+    end
+
+    def execute_add_foreign_key(fk)
+      on_delete = "ON DELETE CASCADE" if fk.cascade
+      on_delete = "ON DELETE SET NULL" if fk.set_null
+      execute_sql %{ALTER TABLE #{fk.from_table}
+                ADD CONSTRAINT #{fk.constraint_name}
+                FOREIGN KEY (#{fk.from_column})
+                REFERENCES #{fk.to_table} (#{fk.to_column})
+                #{on_delete}}
+    end
+
+    def execute_drop_foreign_key(constraint_name, from_table, from_column)
+      execute_sql %{ALTER TABLE #{from_table}
+                DROP CONSTRAINT #{constraint_name}}
+    end
+
+    def execute_sql(sql)
+      ActiveRecord::Base.connection.execute(sql)
+    end
+
+  end
+
+end

data/lib/db_leftovers/definition.rb

@@ -0,0 +1,16 @@
+module DBLeftovers
+
+  class Definition
+    def self.define(opts={}, &block)
+      opts = {
+        :do_indexes => true,
+        :do_foreign_keys => true
+      }.merge(opts)
+      dsl = DSL.new
+      dsl.define(&block)
+      dsl.record_indexes        if opts[:do_indexes]
+      dsl.record_foreign_keys   if opts[:do_foreign_keys]
+    end
+  end
+
+end

data/lib/db_leftovers/dsl.rb

@@ -1,97 +1,5 @@
 module DBLeftovers
 
-  class Definition
-    def self.define(opts={}, &block)
-      opts = {
-        :do_indexes => true,
-        :do_foreign_keys => true
-      }.merge(opts)
-      dsl = DSL.new
-      dsl.define(&block)
-      dsl.record_indexes        if opts[:do_indexes]
-      dsl.record_foreign_keys   if opts[:do_foreign_keys]
-    end
-  end
-
-
-  private
-
-  # Just a struct to hold all the info for one index:
-  class Index
-    attr_accessor :table_name, :column_names, :index_name,
-      :where_clause, :unique
-
-    def initialize(table_name, column_names, opts={})
-      opts = {
-        :where => nil,
-        :unique => false,
-      }.merge(opts)
-      opts.keys.each do |k|
-        raise "Unknown option: #{k}" unless [:where, :unique, :name].include?(k)
-      end
-      @table_name = table_name.to_s
-      @column_names = [column_names].flatten.map{|x| x.to_s}
-      @where_clause = opts[:where]
-      @unique = opts[:unique]
-      @index_name = opts[:name] || choose_name(@table_name, @column_names)
-    end
-
-    def unique?
-      @unique
-    end
-
-    private 
-
-    def choose_name(table_name, column_names)
-      "index_#{table_name}_on_#{column_names.join('_and_')}"
-    end
-
-  end
-
-
-  class ForeignKey
-    attr_accessor :constraint_name, :from_table, :from_column, :to_table, :to_column, :set_null, :cascade
-
-    def initialize(constraint_name, from_table, from_column, to_table, to_column, opts={})
-      opts = {
-        :set_null => false,
-        :cascade => false
-      }.merge(opts)
-      opts.keys.each do |k|
-        raise "Unknown option: #{k}" unless [:set_null, :cascade].include?(k)
-      end
-      @constraint_name = constraint_name
-      @from_table = from_table
-      @from_column = from_column
-      @to_table = to_table
-      @to_column = to_column
-
-      @set_null = opts[:set_null]
-      @cascade = opts[:cascade]
-
-      raise "ON DELETE can't be both set_null and cascade" if @set_null and @cascade
-    end
-  end
-
-  class TableDSL
-    def initialize(dsl, table_name)
-      @dsl = dsl
-      @table_name = table_name
-    end
-
-    def define(&block)
-      instance_eval(&block)
-    end
-
-    def index(column_names, opts={})
-      @dsl.index(@table_name, column_names, opts)
-    end
-
-    def foreign_key(from_column, to_table, to_column='id', opts={})
-      @dsl.foreign_key(@table_name, from_column, to_table, to_column, opts)
-    end
-  end
-
   class DSL
     def initialize
       @db = DatabaseInterface.new
@@ -201,89 +109,4 @@ module DBLeftovers
 
   end
 
-  class DatabaseInterface
-
-    def lookup_all_indexes
-      ret = {}
-      sql = <<-EOQ
-          SELECT  n.nspname as "Schema", c.relname as "Name",
-                  CASE c.relkind WHEN 'r' THEN 'table' WHEN 'v' THEN 'view' WHEN 'i' THEN 'index' WHEN 'S' THEN 'sequence' WHEN 's' THEN 'special' END as "Type",
-                  u.usename as "Owner",
-                  c2.relname as "Table"
-          FROM    pg_catalog.pg_class c
-                  JOIN pg_catalog.pg_index i ON i.indexrelid = c.oid
-                  JOIN pg_catalog.pg_class c2 ON i.indrelid = c2.oid
-                  LEFT JOIN pg_catalog.pg_user u ON u.usesysid = c.relowner
-                  LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-          WHERE   c.relkind IN ('i','')
-          AND     n.nspname NOT IN ('pg_catalog', 'pg_toast')
-          AND     pg_catalog.pg_table_is_visible(c.oid)
-          AND     c.relname NOT LIKE '%_pkey'
-          AND     c2.relname NOT IN ('delayed_jobs', 'schema_migrations')
-          ORDER BY 1,2;
-      EOQ
-      ActiveRecord::Base.connection.select_rows(sql).each do |schema, index_name, object_type, owner, table_name|
-        ret[index_name] = table_name
-      end
-      return ret
-    end
-
-    def lookup_all_foreign_keys
-      ret = {}
-      sql = <<-EOQ
-          SELECT  t.constraint_name, t.table_name, k.column_name, t.constraint_type, c.table_name, c.column_name
-          FROM    information_schema.table_constraints t,
-                  information_schema.constraint_column_usage c,
-                  information_schema.key_column_usage k
-          WHERE   t.constraint_name = c.constraint_name
-          AND     k.constraint_name = c.constraint_name
-          AND     t.constraint_type = 'FOREIGN KEY'
-      EOQ
-      ActiveRecord::Base.connection.select_rows(sql).each do |constr_name, from_table, from_column, constr_type, to_table, to_column|
-        ret[constr_name] = ForeignKey.new(constr_name, from_table, from_column, to_table, to_column)
-      end
-      return ret
-    end
-
-    def execute_add_index(idx)
-      unique = idx.unique? ? 'UNIQUE' : ''
-      where = idx.where_clause.present? ? "WHERE #{idx.where_clause}" : ''
-
-      sql = <<-EOQ
-        CREATE #{unique} INDEX #{idx.index_name}
-        ON #{idx.table_name}
-        (#{idx.column_names.join(', ')})
-        #{where}
-      EOQ
-      execute_sql(sql)
-    end
-
-    def execute_drop_index(table_name, index_name)
-      sql = <<-EOQ
-          DROP INDEX #{index_name}
-      EOQ
-      execute_sql(sql)
-    end
-
-    def execute_add_foreign_key(fk)
-      on_delete = "ON DELETE CASCADE" if fk.cascade
-      on_delete = "ON DELETE SET NULL" if fk.set_null
-      execute_sql %{ALTER TABLE #{fk.from_table}
-                ADD CONSTRAINT #{fk.constraint_name}
-                FOREIGN KEY (#{fk.from_column})
-                REFERENCES #{fk.to_table} (#{fk.to_column})
-                #{on_delete}}
-    end
-
-    def execute_drop_foreign_key(constraint_name, from_table, from_column)
-      execute_sql %{ALTER TABLE #{from_table}
-                DROP CONSTRAINT #{constraint_name}}
-    end
-
-    def execute_sql(sql)
-      ActiveRecord::Base.connection.execute(sql)
-    end
-
-  end
-
 end

data/lib/db_leftovers/foreign_key.rb

@@ -0,0 +1,27 @@
+module DBLeftovers
+
+  class ForeignKey
+    attr_accessor :constraint_name, :from_table, :from_column, :to_table, :to_column, :set_null, :cascade
+
+    def initialize(constraint_name, from_table, from_column, to_table, to_column, opts={})
+      opts = {
+        :set_null => false,
+        :cascade => false
+      }.merge(opts)
+      opts.keys.each do |k|
+        raise "Unknown option: #{k}" unless [:set_null, :cascade].include?(k)
+      end
+      @constraint_name = constraint_name
+      @from_table = from_table
+      @from_column = from_column
+      @to_table = to_table
+      @to_column = to_column
+
+      @set_null = opts[:set_null]
+      @cascade = opts[:cascade]
+
+      raise "ON DELETE can't be both set_null and cascade" if @set_null and @cascade
+    end
+  end
+
+end

data/lib/db_leftovers/index.rb

@@ -0,0 +1,35 @@
+module DBLeftovers
+
+  # Just a struct to hold all the info for one index:
+  class Index
+    attr_accessor :table_name, :column_names, :index_name,
+      :where_clause, :unique
+
+    def initialize(table_name, column_names, opts={})
+      opts = {
+        :where => nil,
+        :unique => false,
+      }.merge(opts)
+      opts.keys.each do |k|
+        raise "Unknown option: #{k}" unless [:where, :unique, :name].include?(k)
+      end
+      @table_name = table_name.to_s
+      @column_names = [column_names].flatten.map{|x| x.to_s}
+      @where_clause = opts[:where]
+      @unique = opts[:unique]
+      @index_name = opts[:name] || choose_name(@table_name, @column_names)
+    end
+
+    def unique?
+      @unique
+    end
+
+    private 
+
+    def choose_name(table_name, column_names)
+      "index_#{table_name}_on_#{column_names.join('_and_')}"
+    end
+
+  end
+
+end

data/lib/db_leftovers/table_dsl.rb

@@ -0,0 +1,22 @@
+module DBLeftovers
+
+  class TableDSL
+    def initialize(dsl, table_name)
+      @dsl = dsl
+      @table_name = table_name
+    end
+
+    def define(&block)
+      instance_eval(&block)
+    end
+
+    def index(column_names, opts={})
+      @dsl.index(@table_name, column_names, opts)
+    end
+
+    def foreign_key(from_column, to_table, to_column='id', opts={})
+      @dsl.foreign_key(@table_name, from_column, to_table, to_column, opts)
+    end
+  end
+
+end

data/lib/db_leftovers.rb

@@ -1,4 +1,9 @@
+require 'db_leftovers/database_interface.rb'
+require 'db_leftovers/index.rb'
+require 'db_leftovers/foreign_key.rb'
+require 'db_leftovers/table_dsl.rb'
 require 'db_leftovers/dsl.rb'
+require 'db_leftovers/definition.rb'
 
 module DBLeftovers
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: db_leftovers
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-17 00:00:00.000000000Z
+date: 2012-01-20 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &86541750 !ruby/object:Gem::Requirement
+  requirement: &80697560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *86541750
+  version_requirements: *80697560
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &86541450 !ruby/object:Gem::Requirement
+  requirement: &80697230 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 2.3.0
   type: :development
   prerelease: false
-  version_requirements: *86541450
+  version_requirements: *80697230
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &86541140 !ruby/object:Gem::Requirement
+  requirement: &80696850 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *86541140
+  version_requirements: *80696850
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &86540780 !ruby/object:Gem::Requirement
+  requirement: &80691820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 1.6.4
   type: :development
   prerelease: false
-  version_requirements: *86540780
+  version_requirements: *80691820
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &86540450 !ruby/object:Gem::Requirement
+  requirement: &80691390 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *86540450
+  version_requirements: *80691390
 description: ! "        Define indexes and foreign keys for your Rails app\n        in
   one place using an easy-to-read DSL,\n        then run a rake task to bring your
   database up-to-date.\n"
@@ -74,21 +74,30 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE.txt
-- README.rdoc
+- README.html
+- README.md
+- TODO
 files:
 - .document
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
-- README.rdoc
+- README.md
 - Rakefile
 - VERSION
 - db_leftovers.gemspec
 - lib/db_leftovers.rb
+- lib/db_leftovers/database_interface.rb
+- lib/db_leftovers/definition.rb
 - lib/db_leftovers/dsl.rb
+- lib/db_leftovers/foreign_key.rb
+- lib/db_leftovers/index.rb
+- lib/db_leftovers/table_dsl.rb
 - lib/tasks/leftovers.rake
 - spec/db_leftovers_spec.rb
 - spec/spec_helper.rb
+- README.html
+- TODO
 homepage: http://github.com/pjungwir/db_leftovers
 licenses:
 - MIT
@@ -104,7 +113,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 347591153
+      hash: -934339327
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/README.rdoc

@@ -1,19 +0,0 @@
-= db_leftovers
-
-Description goes here.
-
-== Contributing to db_leftovers
- 
-* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
-* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
-* Fork the project
-* Start a feature/bugfix branch
-* Commit and push until you are happy with your contribution
-* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
-* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
-
-== Copyright
-
-Copyright (c) 2012 Paul A. Jungwirth. See LICENSE.txt for
-further details.
-