hgimenez-peegee 0.1.0 → 0.1.1

data/README.textile

@@ -7,8 +7,6 @@ h1. Why?
 This project started with the need to improve the performance of PostgreSQL's CLUSTER command. While clustering your database tables improves query performance significantly, the actual process of clustering takes unacceptable amounts of time. For instance, it may take roughly 20 hours on a moderately big set of tables (around 60GB). Your milage may vary, of course.
 Refactoring the clustering functionality surfaced a clean set of utilities that resulted in the creation of this gem. Some are useful, and some are just pointless.
 
-The initial code for this gem was created during the Boston.rb hackfest at Thoughtbot, on April 7th, 2009.
-
 h1. Example usage
 
 Assuming we're in a Rails app, you can simply do:
@@ -27,12 +25,11 @@ After the call to drop, the @dependent_foreign_keys instance variable on the peo
 The strategy used for clustering a table is to store all dependencies in order to restore them later (as viewed above), and move all of the table's data on the order given by a certain index. This is all executed in a database transaction in case it blows up. The result should be just like the pgsql native CLUSTER command:
 <pre><code>people_table.cluster('people_pk') #must specify an index by which to cluster</code></pre>
 
-h2. Todo
+h1. Todo
 
 The first order of business will be to create specs where applicable.
 
-Then, the idea is to keep adding functionality that may be useful for DBAs or application developers and other PostgreSQL users. Some that come to mind are:
-
+Then, the idea is to keep adding functionality that may be useful for DBAs or application developers and other PostgreSQL users. Some that come to mind are: 
 * Ability to clean out all of table's index and foreign key names, following a given pattern. On occasions, table names are altered leaving behind pesky legacy names for related objects.
 * Ability to identify database stinks. For instance: 
 ** tables without primary keys, or indexes (which are not pure join tables)
@@ -49,6 +46,18 @@ I would also like to make this code ORM agnostic. Right now, it depends on Activ
 
 Please fork away and help improve it.
 
+h1. Revision History
+
+* Version 0.1.1 (April 13th, 2009): 
+** Set up RSpec testing environment. Started creating test suite.
+** Added the Configuration singleton class, which for now allows the user to specify which indexes to cluster each table by.
+** Added exists? class method to Peegee::Table class. Creating a Peegee::Table instance now fails if the table does not exist in the database.
+** Added bang (!) methods to Peegee::Table class, which force the lookup of foreign_keys!, constraints!, indexes!, etc, even when they're already cached.
+** Fixed bug in cluster method.
+
+* Version 0.1.0 (April 10th, 2009): 
+** First release.
+
 h1. License
 
 Copyright (c) 2009 Harold A. Gimenez, released under the MIT license.

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 1
-:patch: 0
+:patch: 1

data/lib/peegee.rb

@@ -1,6 +1,8 @@
-require 'peegee/table'
-require 'peegee/constraint'
-require 'peegee/unique_constraint'
-require 'peegee/primary_key'
-require 'peegee/foreign_key'
-require 'peegee/index'
+require File.dirname(__FILE__) + '/peegee/table'
+require File.dirname(__FILE__) + '/peegee/constraint'
+require File.dirname(__FILE__) + '/peegee/unique_constraint'
+require File.dirname(__FILE__) + '/peegee/primary_key'
+require File.dirname(__FILE__) + '/peegee/foreign_key'
+require File.dirname(__FILE__) + '/peegee/index'
+require File.dirname(__FILE__) + '/peegee/configuration'
+require File.dirname(__FILE__) + '/peegee/table_does_not_exist_error'

data/lib/peegee/clustering.rb

@@ -3,32 +3,34 @@ module Peegee
 
     # Clusters this table. See http://www.postgresql.org/docs/8.3/interactive/sql-cluster.html
     # Optionally specify the index to cluster by (by name or Peegee::Index object).
-    # If the index is not specify, it will try to induce which index to 
-    # use by looking at postgresql's internals. If it can't find out,
-    # an exception will be raised.
+    # The index to use would ideally be specified using the <tt>Peegee::Configuration</tt> 
+    # instance. If the index is not specified, it will try to induce which index to 
+    # use by looking at postgresql's internals. 
+    # If a proper index can't be found, an exception will be raised.
     def cluster(cluster_index = nil)
       cluster_index = find_cluster_index(cluster_index)
       puts "Cluster index is: #{cluster_index.inspect}"
       puts "Cluster index type is: #{cluster_index.class.name}"
-      dependencies = remember_dependencies
+      dependencies, dependent_foreign_keys = remember_dependencies
       ActiveRecord::Base.transaction do
-        puts "Clustering #{@table_name} by #{cluster_index.index_name} (with order => #{cluster_index.order})"
-        dependencies.map { |dep| dep.drop }
+        dependent_foreign_keys.map { |dfk| dfk.drop }
         create_tmp_table
         move_data(cluster_index)
         drop_original_and_rename_tmp_table
         dependencies.reverse.map { |dep| dep.create }
+        dependent_foreign_keys.map { |dfk| dfk.create }
       end
     end
 
     private
 
-      # Retrieves the Peegee::Index object that will be used
-      # for clustering this table. The cluster_index parameter can
-      # be either a string representing the index name, or a Peegee::Index object.
+      # Retrieves the <tt>Peegee::Index</tt> object that will be used
+      # for clustering this table. The <tt>cluster_index</tt> parameter can
+      # be either a string representing the index name, or a <tt>Peegee::Index</tt> object.
       # Raises an exception if either a proper index was not found
-      # or more than one index was found given a cluster_index name.
+      # or more than one index was found given a <tt>cluster_index</tt> name.
       def find_cluster_index(cluster_index)
+        cluster_index = Peegee::Configuration.instance.cluster_indexes[self.table_name.to_sym].to_s if cluster_index.nil?
         return cluster_index if cluster_index.kind_of?(Peegee::Index)
         the_index = nil
         if cluster_index #cluster_index is specified
@@ -67,7 +69,7 @@ module Peegee
       # drop the table being clustered (to clean out the dependency on
       # the sequence).
       # This method is called after having created the tmp table, otherwise it will fail.
-      #
+      #--
       # The method for finding a table's sequence is hackish. 
       # TODO: Find a better method for finding a table's sequence.
       def reasign_sequence_to_tmp_table
@@ -89,8 +91,6 @@ module Peegee
           seq[2].match /nextval\('[\"']{0,2}(\w*)[\"']{0,2}.*'::regclass\)/
           sequence_name = $1 #the match above...
           ActiveRecord::Base.connection.execute("ALTER SEQUENCE \"#{sequence_name}\" OWNED BY #{@table_name}_tmp.#{seq[0]}")
-        else
-          puts "\n\n\t*****#{@table_name} apparently doesn't have a sequence"
         end
       end
 
@@ -110,8 +110,8 @@ module Peegee
       # dependent foreign keys, and indexes. 
       def remember_dependencies
         dependencies = []
-        dependencies << foreign_keys << dependent_foreign_keys << indexes
-        dependencies.flatten
+        dependencies << foreign_keys << indexes
+        return dependencies.flatten, dependent_foreign_keys 
       end
 
   end

data/lib/peegee/configuration.rb

@@ -0,0 +1,23 @@
+require 'singleton'
+module Peegee
+
+  class Configuration
+    include Singleton
+
+    # The mappings between tables and indexes, used 
+    # for executing Peegee's implementation of the Postgres CLUSTER command.
+    # The hash maps tables to indexes. You may pass
+    # either a 'string' or a :symbol.
+    # For example: 
+    # <tt>cluster_indexes = {:posts => :ix_posts_on_active_and_created_at,
+    #                    'users' => 'ix_user_on_active_and_person_id'}</tt>
+    @cluster_indexes = {}
+    attr_accessor :cluster_indexes
+
+    def self.run(&block)
+      yield Configuration.instance
+    end
+
+  end
+
+end

data/lib/peegee/table.rb

@@ -3,35 +3,93 @@ module Peegee
 
   class Table
     include Peegee::Clustering
+
+    attr_accessor :table_name
     
+    # Creates a new instance of Peegee::Table.
+    # Receives an +opts+ hash paramater, which expects
+    # to contain a key called <tt>:table_name</tt>.
+    # A TableDoesNotExistError is thrown if the table
+    # with the supplied name is not found in the database.
     def initialize(opts = {})
-      @table_name = opts[:table_name]
+      if Peegee::Table.exists?(opts[:table_name])
+        @table_name = opts[:table_name]
+      else
+        raise TableDoesNotExistError, "Table #{opts[:table_name]} does not exist", caller
+      end
     end
 
+    # Class method that finds out if a given table name exists in the database.
+    def self.exists?(table_name)
+      sql = "select * from pg_class where relname = '#{table_name}' and relkind = 'r'"
+      !(ActiveRecord::Base.connection.execute(sql).entries.flatten.size == 0)
+    end
+
+    # The postgresql OID for this table.
     def oid
       @oid ||= fetch_oid
     end
 
+    # Returns an array of all foreign keys for this table, as <tt>Peegee::ForeignKey</tt> objects. 
+    # The first time this method is called, foreign keys are retrieved from the database 
+    # and cached in an instance variable. Subsequence calls will use the cached values. 
+    # To force a lookup of foreign keys use the <tt>foreign_keys!</tt> method instead.
     def foreign_keys
       @foreign_keys ||= fetch_foreign_keys
     end
 
+    def foreign_keys!
+      fetch_foreign_keys
+    end
+
+    # Returns an array of all dependent foreign keys for this table, as <tt>Peegee::ForeignKey</tt> objects. 
+    # The first time this method is called, dependent foreign keys are retrieved from the database 
+    # and cached in an instance variable. Subsequence calls will use the cached values. 
+    # To force a lookup of dependent foreign keys use the <tt>dependent_foreign_keys!</tt> method instead.
     def dependent_foreign_keys
       @dependent_foreign_keys ||= fetch_dependent_foreign_keys
     end
 
-    def primary_keys
-      @primary_keys ||= fetch_primary_keys
+    def dependent_foreign_keys!
+      fetch_dependent_foreign_keys
+    end
+
+    # Returns an array of primary keys for this table, as <tt>Peegee::PrimaryKey</tt> objects. 
+    # The first time this method is called, primary keys are retrieved from the database 
+    # and cached in an instance variable. Subsequence calls will use the cached values. 
+    # To force a lookup of primary keys use the <tt>primary_key!</tt> method instead.
+    def primary_key
+      @primary_key ||= fetch_primary_key
+    end
+
+    def primary_key!
+      fetch_primary_key
     end
 
+    # Returns an array of unique constraints for this table, as <tt>Peegee::UniqueConstraint</tt> objects. 
+    # The first time this method is called, unique constraints are retrieved from the database 
+    # and cached in an instance variable. Subsequence calls will use the cached values. 
+    # To force a lookup of unique constraints use the <tt>unique_constraints!</tt> method instead.
     def unique_constraints
       @unique_constraints ||= fetch_unique_constraints
     end
 
+    def unique_constraints!
+      fetch_unique_constraints
+    end
+
+    # Returns an array of indexes for this table, as <tt>Peegee::indexes</tt> objects. 
+    # The first time this method is called, unique constraints are retrieved from the database 
+    # and cached in an instance variable. Subsequence calls will use the cached values. 
+    # To force a lookup of unique constraints use the <tt>indexes!</tt> method instead.
     def indexes
       @indexes ||= fetch_indexes
     end
 
+    def indexes!
+      fetch_indexes
+    end
+
     # Returns the DDL for this table as a string.
     def ddl
       sql = 'SELECT a.attname, ' +
@@ -62,8 +120,8 @@ module Peegee
       ddl.gsub('\\','')
     end
 
-
     private
+      # Retrieves this table's OID from the database.
       def fetch_oid
         sql = 'SELECT c.oid ' +
         ' FROM pg_catalog.pg_class c ' +
@@ -73,9 +131,8 @@ module Peegee
         return ActiveRecord::Base.connection.execute(sql).entries[0]
       end
 
-
-
-      def fetch_primary_keys
+      # Retrieves this table's primary key from the database.
+      def fetch_primary_key
         sql = 'select  conname ' +
             ' , pg_get_constraintdef(pk.oid, true) as foreign_key ' +
             ' from pg_catalog.pg_constraint pk ' +
@@ -92,7 +149,7 @@ module Peegee
         end
       end
 
-
+      # Retrieves this table's unique constraints from the database.
       def fetch_unique_constraints
         sql = 'select  conname ' +
             ' , pg_get_constraintdef(uc.oid, true) as foreign_key ' +
@@ -110,6 +167,7 @@ module Peegee
         end
       end
 
+      # Retrieves this table's foreign keys from the database.
       def fetch_foreign_keys
         sql = 'select  conname ' +
             ' , pg_get_constraintdef(fk.oid, true) as foreign_key ' +
@@ -128,6 +186,8 @@ module Peegee
 
       end
 
+      # Retrieves this table's dependent foreign keys from the database.
+      # A dependent foreign key, is any foreign key that references this table.
       def fetch_dependent_foreign_keys
         sql = 'select pg_constraint.conname,' +
             'dep_table.relname, ' +
@@ -144,6 +204,7 @@ module Peegee
         end
       end
 
+      # Retrieves indexes for this table from the database.
       def fetch_indexes
         sql = "SELECT pg_get_indexdef(i.indexrelid, 0, true) as index_definition " +
             ", c2.relname as index_name " +
@@ -151,7 +212,6 @@ module Peegee
             "FROM pg_catalog.pg_class c, pg_catalog.pg_class c2, pg_catalog.pg_index i " +
             "WHERE c.oid = '#{@table_name}'::regclass AND c.oid = i.indrelid AND i.indexrelid = c2.oid " #+
             #"AND i.indisprimary = false" #don't get primary key constraints...
-        #indexes = ActiveRecord::Base.connection.execute(sql).entries.collect{ |i| i[0] + ';'}
         indexes = ActiveRecord::Base.connection.execute(sql).entries
         return indexes.collect do |i| 
           Peegee::Index.new(:table_name => @table_name,
@@ -161,8 +221,6 @@ module Peegee
           end
       end
 
-
-
   end
 
 end

data/lib/peegee/table_does_not_exist_error.rb

@@ -0,0 +1,4 @@
+module Peegee
+  class TableDoesNotExistError < Exception
+  end
+end

data/peegee.gemspec

@@ -1,12 +1,12 @@
 # -*- encoding: utf-8 -*-
 
-Gem::Specification.new do |s| 
+Gem::Specification.new do |s|
   s.name = %q{peegee}
-  s.version = "0.1.0"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Harold A. Gimenez"]
-  s.date = %q{2009-04-10}
+  s.date = %q{2009-04-13}
   s.email = %q{harold.gimenez@gmail.com}
   s.extra_rdoc_files = [
     "README.textile"
@@ -17,15 +17,21 @@ Gem::Specification.new do |s|
     "VERSION.yml",
     "lib/peegee.rb",
     "lib/peegee/clustering.rb",
+    "lib/peegee/configuration.rb",
     "lib/peegee/constraint.rb",
     "lib/peegee/foreign_key.rb",
     "lib/peegee/index.rb",
     "lib/peegee/primary_key.rb",
     "lib/peegee/table.rb",
+    "lib/peegee/table_does_not_exist_error.rb",
     "lib/peegee/unique_constraint.rb",
     "peegee.gemspec",
-    "spec/peegee_spec.rb",
-    "spec/spec_helper.rb"
+    "spec/factories.rb",
+    "spec/fixtures/activerecord_models.rb",
+    "spec/fixtures/structure.sql",
+    "spec/peegee_helper.rb",
+    "spec/spec_helper.rb",
+    "spec/unit/peegee_table_spec.rb"
   ]
   s.has_rdoc = true
   s.homepage = %q{http://github.com/hgimenez/peegee}
@@ -35,8 +41,11 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.1}
   s.summary = %q{A set of utilities for doing PostgreSQL database related stuffs from ruby.}
   s.test_files = [
-    "spec/peegee_spec.rb",
-    "spec/spec_helper.rb"
+    "spec/factories.rb",
+    "spec/fixtures/activerecord_models.rb",
+    "spec/peegee_helper.rb",
+    "spec/spec_helper.rb",
+    "spec/unit/peegee_table_spec.rb"
   ]
 
   if s.respond_to? :specification_version then

data/spec/factories.rb

@@ -0,0 +1,9 @@
+require 'faker'
+Factory.define :user do |u|
+  u.name { Faker::Name.name }
+  u.email { Faker::Internet.email }
+  u.login { Faker::Internet.user_name }
+  u.password { Faker::Lorem.words.join('') } 
+  u.created_at { Time.now }
+  u.updated_at { Time.now }
+end

data/spec/fixtures/activerecord_models.rb

@@ -0,0 +1,8 @@
+class User < ActiveRecord::Base
+  has_many :posts#, :foreign_key => 'created_by_id'
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :created_by, :class_name => User, :foreign_key => 'created_by_id'
+  belongs_to :updated_by, :class_name => User, :foreign_key => 'updated_by_id'
+end

data/spec/fixtures/structure.sql

@@ -0,0 +1,62 @@
+DROP TABLE IF EXISTS posts;
+DROP TABLE IF EXISTS users;
+
+-- Table: users
+CREATE TABLE users
+(
+  id serial NOT NULL,
+  "name" character varying(100),
+  email character varying(255) NOT NULL,
+  "login" character varying(40) NOT NULL DEFAULT ''::character varying,
+  "password" character varying(40),
+  "admin" boolean NOT NULL DEFAULT false,
+  notes text,
+  lock_version integer DEFAULT 0,
+  salt character varying(255),
+  created_at timestamp without time zone,
+  updated_at timestamp without time zone,
+  CONSTRAINT users_pkey PRIMARY KEY (id)
+)
+WITH (OIDS=FALSE);
+ALTER TABLE users OWNER TO peegee;
+
+-- Index: "login"
+DROP INDEX IF EXISTS "login";
+
+CREATE UNIQUE INDEX "login"
+  ON users
+  USING btree
+  (login);
+
+-- Table: posts
+
+
+CREATE TABLE posts
+(
+  id serial NOT NULL,
+  title character varying(255),
+  body text,
+  status_id integer NOT NULL DEFAULT 1,
+  created_at timestamp without time zone NOT NULL,
+  updated_at timestamp without time zone NOT NULL,
+  published_at timestamp without time zone,
+  created_by_id integer NOT NULL,
+  updated_by_id integer NOT NULL,
+  CONSTRAINT posts_pkey PRIMARY KEY (id),
+  CONSTRAINT fk_posts_created_by_id FOREIGN KEY (created_by_id)
+      REFERENCES users (id) MATCH SIMPLE
+      ON UPDATE NO ACTION ON DELETE NO ACTION,
+  CONSTRAINT fk_posts_updated_by_id FOREIGN KEY (updated_by_id)
+      REFERENCES users (id) MATCH SIMPLE
+      ON UPDATE NO ACTION ON DELETE NO ACTION
+)
+WITH (OIDS=FALSE);
+
+ALTER TABLE posts OWNER TO peegee;
+
+-- Index: ix_posts_on_status_id
+
+CREATE INDEX ix_posts_on_status_id
+  ON posts
+  USING btree
+  (status_id);

data/spec/peegee_helper.rb

@@ -0,0 +1,71 @@
+require 'active_record'
+prefix = defined?(JRUBY_VERSION) ? 'jdbc' : ''
+require "active_record/connection_adapters/#{prefix}postgresql_adapter"
+require 'yaml'
+
+class PeegeeHelper
+
+  attr_accessor :host, :username, :password
+  #attr_reader :path
+  
+  def initialize
+    @path = File.expand_path(File.dirname(__FILE__))
+    @host = 'localhost'
+    @username = 'peegee'
+    @password = 'peegee'
+ 
+    # if you want to overwrite defaults for testing,
+    # do it on spec/fixtures/database.yml
+    if File.exist?('spec/fixtures/database.yml')
+      config = YAML.load(File.open('spec/fixtures/database.yml'))
+      @host = config['host']
+      @username = config['username']
+      @password = config['password']
+    end
+  end
+  
+  def setup_pgsql
+    #Adapter => http://raa.ruby-lang.org/project/postgres-pr/
+    ActiveRecord::Base.establish_connection(
+      :adapter => 'postgresql',
+      :database => 'peegee_test',
+      :username => @username,
+      :password => @password,
+      :host => @host
+    )
+
+    ActiveRecord::Base.logger = Logger.new(active_record_log_file)
+    
+    structure = File.open('spec/fixtures/structure.sql') { |f| f.read.chomp }
+    structure.split(';').each { |sql|
+      ActiveRecord::Base.connection.execute sql unless sql.start_with? '--'
+    }
+    
+    #File.open('spec/fixtures/data.sql') { |f|
+      #while line = f.gets
+        #ActiveRecord::Base.connection.execute line unless line.blank?
+      #end
+    #}
+  end
+
+  def configure_peegee
+    Peegee::Configuration.run do |config|
+      config.cluster_indexes = {
+          :users => :users_pkey,
+          :posts => :ix_posts_on_status_id
+        }
+    end
+  end
+  
+  def reset
+    setup_pgsql
+  end
+
+  AR_LOGFILE = 'tmp/active_record.log'
+  private
+    def active_record_log_file
+      FileUtils.mkdir_p 'tmp'
+      File.new(AR_LOGFILE, 'a') unless File.exists?(AR_LOGFILE)
+    end
+
+end

data/spec/spec_helper.rb

@@ -4,6 +4,10 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'peegee'
 
+require 'spec/peegee_helper'
+require 'factory_girl'
+
 Spec::Runner.configure do |config|
-  
+  Kernel.const_set :RAILS_ROOT, "#{Dir.pwd}/tmp" unless defined?(RAILS_ROOT)
+  require 'spec/fixtures/activerecord_models'
 end

data/spec/unit/peegee_table_spec.rb

@@ -0,0 +1,95 @@
+require 'spec/spec_helper'
+
+describe 'Peegee::Table' do
+
+  before :all do
+    @peegee_helper = PeegeeHelper.new
+    @peegee_helper.reset
+  end
+
+  describe 'when creating a Peegee::Table object' do
+    describe 'when the table does not exist in the DB' do
+      it 'should raise an error' do
+        lambda { 
+          Peegee::Table.new(:table_name => 'foo') 
+        }.should raise_error(
+          Peegee::TableDoesNotExistError
+        )
+      end
+    end
+
+    describe 'when the table exists on the DB' do
+      before :each do
+        @users_table = Peegee::Table.new(:table_name => 'users')
+      end
+      it 'should create a Peegee::Table instance' do
+        @users_table.should be_kind_of(Peegee::Table)
+      end
+    end
+  end
+
+  describe 'clustering a table' do
+
+    def do_cluster
+      @users_table.cluster
+    end
+
+    before :each do
+      @peegee_helper.configure_peegee
+      3.times { Factory.create(:user) }
+      @users = User.all
+      @users_table = Peegee::Table.new(:table_name => 'users')
+      @foreign_keys = @users_table.foreign_keys
+      @dependent_foreign_keys = @users_table.dependent_foreign_keys
+      @primary_key = @users_table.primary_key
+      @unique_constraints = @users_table.unique_constraints
+      @indexes = @users_table.indexes
+    end
+
+    after :each do
+      User.delete_all
+    end
+
+    it 'should maintain all foreign keys on the resulting table' do
+      do_cluster
+      @users_table.foreign_keys!
+      @foreign_keys.each do |fk|
+        @users_table.foreign_keys.should include(fk)
+      end
+      @users_table.foreign_keys.size.should == @foreign_keys.size
+    end
+
+    it 'should maintain all dependent foreign keys on the resulting table' do
+      do_cluster
+      @users_table.dependent_foreign_keys!
+      @dependent_foreign_keys.each do |dpf|
+        @users_table.dependent_foreign_keys.should include(dpf)
+      end
+      @users_table.dependent_foreign_keys.size.should == @dependent_foreign_keys.size
+    end
+
+    it 'should maintain all primary key on the resulting table' do
+      do_cluster
+      @users_table.primary_key!
+      @primary_key.each do |pk|
+        @users_table.primary_key.should include(pk)
+      end
+      @users_table.primary_key.size.should == @primary_key.size
+    end
+
+    it 'should maintain all indexes on the resulting table' do
+      do_cluster
+      @users_table.indexes!
+      @indexes.each do |i|
+        @users_table.indexes.should include(i)
+      end
+      @users_table.indexes.size.should == @indexes.size
+    end
+
+    it 'should maintain all of the data on the resulting table' do
+      do_cluster
+      @users.should == User.all
+    end
+
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hgimenez-peegee
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Harold A. Gimenez
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-10 00:00:00 -07:00
+date: 2009-04-13 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -36,15 +36,21 @@ files:
 - VERSION.yml
 - lib/peegee.rb
 - lib/peegee/clustering.rb
+- lib/peegee/configuration.rb
 - lib/peegee/constraint.rb
 - lib/peegee/foreign_key.rb
 - lib/peegee/index.rb
 - lib/peegee/primary_key.rb
 - lib/peegee/table.rb
+- lib/peegee/table_does_not_exist_error.rb
 - lib/peegee/unique_constraint.rb
 - peegee.gemspec
-- spec/peegee_spec.rb
+- spec/factories.rb
+- spec/fixtures/activerecord_models.rb
+- spec/fixtures/structure.sql
+- spec/peegee_helper.rb
 - spec/spec_helper.rb
+- spec/unit/peegee_table_spec.rb
 has_rdoc: true
 homepage: http://github.com/hgimenez/peegee
 post_install_message: 
@@ -72,5 +78,8 @@ signing_key:
 specification_version: 2
 summary: A set of utilities for doing PostgreSQL database related stuffs from ruby.
 test_files: 
-- spec/peegee_spec.rb
+- spec/factories.rb
+- spec/fixtures/activerecord_models.rb
+- spec/peegee_helper.rb
 - spec/spec_helper.rb
+- spec/unit/peegee_table_spec.rb

data/spec/peegee_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe "Peegee" do
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
-  end
-end