kaplan 0.1.0

data/README.md

@@ -0,0 +1,84 @@
+# Kaplan
+
+## Summary
+
+Kaplan provides some Rake tasks that are helpful in preparing your test database(s), such as seeding/plowing your database, or recreating it from your development database.
+
+For instance, let's say you ran your unit tests, and somehow the database wasn't rolled back correctly. Simply run `rake kaplan:db:reset` -- that will dump the SQL schema for your development database to file and use it to replace your test database, then it will seed your test database.
+
+A more common scenario might be, you ran your Cucumber tests and now you need to reset your integration test database back to zero before you run them again. In that case, add `Kaplan.plow_database()` to your Cucumber initialization file and all is well.
+
+## Rationale
+
+Doesn't Rails already provide a `db:reset` Rake task? Yes, but it runs `db:schema:dump` and `db:schema:load` behind the scenes, which isn't always a foolproof way of dumping your schema (there are a few cases, like custom `id` columns, where Rails drops the ball). `db:clone_structure` is almost always the better way to go. Also, eventually you'll reach a point in your Rails app where you need some data to be always in your development and test databases -- in other words, seed data. It would be nice if the `reset` task also seeded your test database too. Kaplan's `db:reset` task does both of these things.
+
+Also, Rails doesn't give you a way to programmatically reset (or at least seed) your database. So if you want to do it inside of a script, you're forced to `require 'rake'` and then say `Rake::Task.invoke["db:reset"]`. That's ridiculous. Kaplan gives you methods for plowing and seeding the database.
+
+Additionally, Kaplan improves Rails' seeding by 1) truncating the tables that will be seeded first, 2) allowing you to keep environment-specific seed files, and 2) allowing you to use YAML or text files since that's a simpler way of representing data (and you're probably used to seeing YAML for fixture data).
+
+Finally, Kaplan was designed to be framework- and ORM-agnostic. Currently the following are supported:
+
+* **Frameworks:**
+  * Rails
+  * Padrino
+* **ORMs:**
+  * ActiveRecord
+  * Mongoid
+  
+It's easy to add support for another framework or ORM, though.
+
+## Usage
+
+Here are the Rake tasks.
+
+* **kaplan:db:reset** - Resets the database corresponding to the given environment by re-creating it from the development schema and then re-seeding it. Accepts: `RAILS_ENV` (required, must not be "development").
+* **kaplan:db:seed** - Seeds the database corresponding to the given environment with bootstrap data. The tables that will be seeded are truncated first so you don't have to. Accepts: `RAILS_ENV` (optional, default is "development").
+* **kaplan:db:plow** - Truncates tables in the database corresponding to the given environment. By default this just truncates the seed tables, pass `ALL` to truncate everything. Accepts: `RAILS_ENV` (optional, default is "development"), `ALL` (optional).
+* **kaplan:db:clone_structure** - Dumps the structure of the development database to file and copies it to the database corresponding to the given environment. The adapters between the databases must be the same. Accepts: `RAILS_ENV` (required, must not be "development").
+* **kaplan:db:create** - Creates the database corresponding to the given environment. Accepts: `RAILS_ENV` (optional, default is "development").
+* **kaplan:db:drop** - Drops the database corresponding to the given environment. Accepts: `RAILS_ENV` (optional, default is "development").
+
+Seeding is a bit different than Rails's built-in seeding, so I'll talk a little bit about that. Basically, you can still keep seeds in `db/seeds.rb` like before, but if you want to break them into separate files, you can put them in `seeds/`, and Kaplan will look for them there too. In fact, the seed files don't have to be Ruby, they can also be YAML or text files. So a YAML seed file would look like:
+
+    people:
+      -
+        first_name: Joe
+        last_name: Bloe
+        likes: eating spaghetti, watching The Godfather
+      -
+        first_name: Jill
+        last_name: Schmoe
+        likes: biking, watching Family Guy
+
+and a text file would look like (note it looks kind of like CSV, but not quite, because you can't quote fields):
+
+    # first name, last name, likes
+    Joe  Bloe  eating spaghetti, watching The Godfather
+    Jill  Schmoe  biking, watching Family Guy
+
+In addition, you can have environment-specific files. So if I have a directory structure that looks like:
+
+    seeds/
+      people.txt
+      development/
+        cars.rb
+        venues.rb
+      test/
+        cars.rb
+        car_types.yml
+
+Then, when I run `rake kaplan:db:seed` in different environments, this is which tables get populated:
+
+    +-------------+-------------------------+
+    | Environment | Tables                  |
+    +-------------+-------------------------+
+    | development | people, cars, venues    |
+    | production  | people                  |
+    | test        | people, cars, car_types |
+    +-------------+-------------------------+
+
+## Author/License
+
+Kaplan is by Elliot Winkler (<elliot.winkler@gmail.com>).
+
+There isn't a license; you may do what you like with it, as long as I'm not held responsible.

data/kaplan.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "kaplan/version"
+
+Gem::Specification.new do |s|
+  s.name        = "kaplan"
+  s.version     = Kaplan::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Elliot Winkler"]
+  s.email       = ["elliot.winkler@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/kaplan"
+  s.summary     = %q{Database- and framework-agnostic Rake tasks to prepare and seed your test database}
+  s.description = %q{Kaplan provides some Rake tasks that are helpful in preparing your test database(s), such as seeding/plowing your database, or recreating it from your development database.}
+
+  s.files         = ["README.md", "kaplan.gemspec"] + Dir["lib/**/*"]
+  s.test_files    = Dir["{test,spec/features}/**/*"]
+  s.executables   = Dir["bin/**/*"].map {|f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/kaplan.rb

@@ -0,0 +1,172 @@
+require File.dirname(__FILE__) + '/kaplan/railtie' if defined?(Rails)
+
+module Kaplan
+  module DatabaseAdapters
+    module ActiveRecord
+      def database_settings
+        @database_settings ||= ::YAML.load_file("#{project_root}/config/database.yml")
+      end
+
+      def establish_database(env = current_environment)
+        ::ActiveRecord::Base.establish_connection(database_settings[env.to_s])
+      end
+
+      def all_collections
+        ::ActiveRecord::Base.connection.tables - ["schema_migrations"]
+      end
+
+      def plow_collection(name)
+        ::ActiveRecord::Base.connection.execute("TRUNCATE TABLE #{::ActiveRecord::Base.connection.quote_table_name(name)}")
+      end
+    end
+
+    module Mongoid
+      def database_settings
+        @database_settings ||= ::YAML.load_file("#{project_root}/config/database.mongo.yml")
+      end
+
+      def establish_database(env = current_environment)
+        ::Mongoid.config.database = ::Mongo::Connection.new.db(database_settings[env.to_s]["database"])
+      end
+
+      def all_collections
+        ::Mongoid.database.collection_names - ["system.indexes"]
+      end
+
+      def plow_collection(name)
+        ::Mongoid.database.drop_collection(name)
+      end
+    end
+  end
+
+  module WebFrameworks
+    module Rails
+      def project_root
+        ::Rails.root
+      end
+
+      def current_environment
+        ::Rails.env.to_s
+      end
+      
+      def current_environment=(environment)
+        if ::Rails.version.split(".")[0] == "3"
+          ::Rails.env = environment
+        else
+          silence_warnings do
+            ::Rails.instance_variable_set("@_env", nil)
+            Object.const_set(:RAILS_ENV, environment)
+          end
+        end
+        puts "Current environment: #{current_environment}"
+      end
+    end
+
+    module Padrino
+      def project_root
+        ::Padrino.root
+      end
+
+      def current_environment
+        ::Padrino.env.to_s
+      end
+      
+      def current_environment=(environment)
+        silence_warnings do
+          ::Padrino.instance_variable_set("@_env", nil)
+          Object.const_set(:PADRINO_ENV, environment)
+        end
+      end
+    end
+  end
+
+  class << self
+    def choose_database_adapter
+      if defined?(::ActiveRecord)
+        Kaplan.extend(Kaplan::DatabaseAdapters::ActiveRecord)
+      elsif defined?(::Mongoid)
+        Kaplan.extend(Kaplan::DatabaseAdapters::Mongoid)
+      end
+    end
+
+    def choose_web_framework
+      if defined?(::Rails)
+        Kaplan.extend(Kaplan::WebFrameworks::Rails)
+      elsif defined?(::Padrino)
+        Kaplan.extend(Kaplan::WebFrameworks::Padrino)
+      end
+    end
+
+    def seeds(env)
+      (Dir["#{project_root}/seeds/*"] + Dir["#{project_root}/seeds/#{env}/*"]).
+      reject {|filename| File.directory?(filename) }.
+      map do |filename|
+        basename = ::File.basename(filename)
+        basename =~ /^(.+?)\.([^.]+)$/
+        collection_name = $1
+        extension = $2.downcase
+        model = collection_name.classify.constantize
+        [filename, extension, collection_name, model]
+      end
+    end
+
+    LEVELS = [:none, :info, :debug]
+
+    def seed_database(options={})
+      level = LEVELS.index(options[:level] || :debug)
+      options.reverse_merge!(:env => current_environment)
+      puts "Seeding the #{options[:env]} database..." if level > 0
+      establish_database(options[:env])
+      seeds(options[:env]).each do |filename, ext, collection_name, model|
+        if ext == "rb"
+          puts " - Adding data for #{collection_name}..." if level > 1
+          load filename
+        elsif ext == "yml" || ext == "yaml"
+          data = ::YAML.load_file(filename)
+          records = (Hash === data) ? data[data.keys.first] : data
+          puts " - Adding data for #{collection_name}..." if level > 1
+          insert_rows(records, model)
+        else
+          lines = ::File.read(filename).split(/\n/)
+          puts " - Adding data for #{collection_name}..." if level > 1
+          insert_rows_from_csv(lines, model)
+        end
+      end
+    end
+
+    def plow_database(options={})
+      level = LEVELS.index(options[:level] || :debug)
+      options.reverse_merge!(:env => current_environment)
+      puts "Plowing the #{options[:env]} database..." if level > 0
+      establish_database(options[:env])
+      collections = options[:all] ? all_collections : seedable_collections(options[:env])
+      collections.each do |coll|
+        plow_collection(coll)
+        puts " - Plowed #{coll}" if level > 1
+      end
+    end
+
+    def seedable_collections(env)
+      # Remove collections that don't exist
+      seeds(env).map {|filename, ext, collection_name, model| collection_name } & all_collections
+    end
+
+  private
+    def insert_rows(rows, model)
+      rows.each {|row| model.create!(row) }
+    end
+
+    def insert_rows_from_csv(lines, model)
+      columns = lines.shift.sub(/^#[ ]*/, "").split(/,[ ]*/)
+      rows = lines.map do |line|
+        values = line.split(/\t|[ ]{2,}/).map {|v| v =~ /^null$/i ? nil : v }
+        zip = columns.zip(values).flatten
+        Hash[*zip]
+      end
+      insert_rows(rows, model)
+    end
+  end
+end
+
+Kaplan.choose_database_adapter
+Kaplan.choose_web_framework

data/lib/kaplan/railtie.rb

@@ -0,0 +1,10 @@
+require 'kaplan'
+require 'rails'
+
+module Kaplan
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load File.dirname(__FILE__) + "/tasks/kaplan.rake"
+    end
+  end
+end

data/lib/kaplan/tasks/kaplan.rake

@@ -0,0 +1,94 @@
+namespace :kaplan do
+  namespace :db do
+    desc "Resets a database of your choice by re-creating it from the development schema and then re-seeding it"
+    task :reset, [:env] => :environment do |t, args|
+      env = args[:env] || ENV["RAILS_ENV"]
+      raise "Can't reset the dev database" if env == "development"
+      #raise "No environment specified. Pass the environment to the task as an argument to specify the environment." unless env
+      puts "Resetting #{env} database by cloning dev schema and seeding db..."
+      Rake::Task['kaplan:db:clone_structure'].invoke(env)
+      Rake::Task['kaplan:db:seed'].invoke(env)
+    end
+
+    desc "Seeds a database of your choice (default: development) with bootstrap data.\nThe relevant tables are truncated first so you don't have to."
+    task :seed, [:env] => :environment do |t, args|
+      env = args[:env] || ENV["RAILS_ENV"] || "development"
+      #raise "No environment specified. Pass the environment to the task as an argument to specify the environment." unless env
+      Rake::Task['kaplan:db:plow'].invoke(env)
+      Kaplan.seed_database(:env => env)
+      Kaplan.establish_database(env)
+      Rake::Task['db:seed'].invoke
+    end
+
+    desc "Truncates tables in a database of your choice (default: development).\nBy default this just truncates the seed tables, if you want all of them pass ALL=true."
+    task :plow, [:env] => :environment do |t, args|
+      env = args[:env] || ENV["RAILS_ENV"] || "development"
+      #raise "No environment specified. Pass the environment to the task as an argument to specify the environment." unless env
+      all = !!ENV["ALL"]
+      Kaplan.plow_database(:env => env, :all => all)
+    end
+
+    desc "Dumps the structure of the development database to file and copies it to the database of your choice.\nAdapters must be the same."
+    task :clone_structure, [:env] => :environment do |t, args|
+      env = args[:env] || ENV["RAILS_ENV"]
+      raise "Can't clone the dev database to the dev database" if env == "development"
+      #raise "No environment specified. Pass the environment to the task as an argument to specify the environment." unless env
+      puts "Cloning dev structure to #{env} database..."
+
+      abcs = ActiveRecord::Base.configurations
+      adapter = abcs[env]["adapter"]
+      development_adapter = abcs["development"]["adapter"]
+      if adapter != development_adapter
+        raise "Development db adapter and #{env} db adapter must be the same to clone"
+      end
+
+      Kaplan.current_environment = env
+      Kaplan.establish_database
+      Rake::Task['db:drop'].invoke
+      Rake::Task['db:create'].invoke
+
+      Kaplan.current_environment = 'development'
+      Kaplan.establish_database
+      Rake::Task["db:structure:dump"].invoke
+
+      Kaplan.current_environment = env
+      Kaplan.establish_database
+      case adapter
+      when "mysql"
+        ActiveRecord::Base.establish_connection(env)
+        ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
+        IO.readlines("#{RAILS_ROOT}/db/development_structure.sql").join.split("\n\n").each do |table|
+          ActiveRecord::Base.connection.execute(table)
+        end
+      when "postgresql"
+        ENV['PGHOST']     = abcs[env]["host"] if abcs[env]["host"]
+        ENV['PGPORT']     = abcs[env]["port"].to_s if abcs[env]["port"]
+        ENV['PGPASSWORD'] = abcs[env]["password"].to_s if abcs[env]["password"]
+        `psql -U "#{abcs[env]["username"]}" -f #{Rails.root}/db/development_structure.sql #{abcs[env]["database"]}`
+      when "sqlite", "sqlite3"
+        dbfile = abcs[env]["database"] || abcs[env]["dbfile"]
+        `#{abcs[env]["adapter"]} #{dbfile} < #{RAILS_ROOT}/db/development_structure.sql`
+      end
+    end
+
+    desc "Creates a database of your choice (default: development)"
+    task :create, [:env] => :environment do |t, args|
+      env = args[:env] || ENV["RAILS_ENV"] || "development"
+      #raise "No environment specified. Pass the environment to the task as an argument to specify the environment." unless env
+      puts "Creating #{env} database..."
+      Kaplan.current_environment = env
+      Kaplan.establish_database
+      Rake::Task['db:create'].invoke
+    end
+
+    desc "Drops the database of your choice (default: development)"
+    task :drop, [:env] => :environment do |t, args|
+      env = args[:env] || ENV["RAILS_ENV"] || "development"
+      #raise "No environment specified. Pass the environment to the task as an argument to specify the environment." unless env
+      puts "Dropping #{env} database..."
+      Kaplan.current_environment = env
+      Kaplan.establish_database
+      Rake::Task['db:drop'].invoke
+    end
+  end
+end

data/lib/kaplan/version.rb

@@ -0,0 +1,3 @@
+module Kaplan
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: kaplan
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Elliot Winkler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-29 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Kaplan provides some Rake tasks that are helpful in preparing your test database(s), such as seeding/plowing your database, or recreating it from your development database.
+email: 
+- elliot.winkler@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- kaplan.gemspec
+- lib/kaplan/railtie.rb
+- lib/kaplan/tasks/kaplan.rake
+- lib/kaplan/version.rb
+- lib/kaplan.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/kaplan
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Database- and framework-agnostic Rake tasks to prepare and seed your test database
+test_files: []
+