bio-gem 0.2.2 → 0.3.0

data/Gemfile.lock

@@ -2,11 +2,11 @@ GEM
   remote: http://rubygems.org/
   specs:
     git (1.2.5)
-    jeweler (1.5.1)
+    jeweler (1.5.2)
       bundler (~> 1.0.0)
       git (>= 1.2.5)
       rake
-    rake (0.8.7)
+    rake (0.9.2)
     rcov (0.9.9)
     shoulda (2.11.3)
 

data/README.rdoc

@@ -1,7 +1,9 @@
 = bioruby-gem
 
-BioGem is a scaffold generator for those Bioinformaticans who want to start coding an application or a library
-for using/extending BioRuby's core library and sharing it through http://rubygems.org .
+BioGem is a scaffold generator for those Bioinformaticans who want to
+start coding an application or a library for using/extending BioRuby's
+core library and sharing it through http://rubygems.org . Biogems are
+listed at http://biogems.info
 
 The basic idea is to simplify and promote a modular approach to the BioRuby package.
 
@@ -52,8 +54,11 @@ Some of these steps have been condensed:
 	    |-- Rakefile
 	    |-- lib
 	    |   `-- bio-mystuff.rb
-	    |-- db [optional = --with-db]
-	    |   `-- empty but put here your datasets or database(SQLite3?)	
+	    |-- conf[optional = --with-db]
+	    |   `-- database.yml put here the configuration of your database like in a rails app
+	    |-- db  [optional = --with-db] empty but put here your datasets or database(SQLite3?)
+	    |   |-- seeds.rb a file containing the preloaded datasets, they will be loaded during db setup process
+	    |   `-- migrate directory for migration, you must create migrations by hand, there is a template inside.
 	    `-- test
 	        |-- data [optional = --with-test-data]
 	        |-- helper.rb
@@ -80,6 +85,7 @@ Usage: biogem [options] reponame
 e.g. biogem the-perfect-gem
         --directory [DIRECTORY]      specify the directory to generate into
 These options are for BioGem
+        --meta                       create a meta package, just the Rakefile, Gemfile, Licence, Readme. This options takes the precedence over every other option.
         --with-bin                   create the bin directory and an executable template script called bioreponame
         --with-db                    create the database directory for a db application-library
         --with-test-data             create the data directory inside the test directory if the user need to set up a test with its own dataset
@@ -118,6 +124,44 @@ These options are for Jeweler
         --rdoc                       use rdoc for documentation
     -h, --help                       display this help and exit
 
+== Tasks
+
+	rake build               # Build gem into pkg/
+	rake clobber_rcov        # Remove rcov products for rcov
+	rake clobber_rdoc        # Remove rdoc products
+	rake console[script]     # Start IRB with all runtime dependencies loaded
+	rake db:create           # Create the database from config/database.yml for the current default (use db:create:all to create all dbs in the config)
+	rake db:drop             # Drops the database for the current default (use db:drop:all to drop all databases)
+	rake db:fixtures:load    # Load fixtures into the current environment's database.
+	rake db:migrate          # Migrate the database (options: VERSION=x, VERBOSE=false).
+	rake db:migrate:status   # Display status of migrations
+	rake db:rollback         # Rolls the schema back to the previous version (specify steps w/ STEP=n).
+	rake db:schema:dump      # Create a db/schema.rb file that can be portably used against any DB supported by AR
+	rake db:schema:load      # Load a schema.rb file into the database
+	rake db:seed             # Load the seed data from db/seeds.rb
+	rake db:setup            # Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the db first)
+	rake db:structure:dump   # Dump the database structure to an SQL file
+	rake db:version          # Retrieves the current schema version number
+	rake gemcutter:release   # Release gem to Gemcutter
+	rake gemspec             # Generate and validate gemspec
+	rake gemspec:debug       # Display the gemspec for debugging purposes, as jeweler knows it (not from the filesystem)
+	rake gemspec:generate    # Regenreate the gemspec on the filesystem
+	rake gemspec:release     # Regenerate and validate gemspec, and then commits and pushes to git
+	rake gemspec:validate    # Validates the gemspec on the filesystem
+	rake git:release         # Tag and push release to git.
+	rake install             # Build and install gem using `gem install`
+	rake rcov                # Analyze code coverage with tests
+	rake rdoc                # Build the rdoc HTML Files
+	rake release             # Release gem
+	rake rerdoc              # Force a rebuild of the RDOC files
+	rake test                # Run tests
+	rake version             # Displays the current version
+	rake version:bump:major  # Bump the major version by 1
+	rake version:bump:minor  # Bump the a minor version by 1
+	rake version:bump:patch  # Bump the patch version by 1
+	rake version:write       # Writes out an explicit version.
+
+
 == NoTes For Developers
 
 * A GitHub Account is required and you MUST create a repository for your new bioruby plugin.
@@ -133,7 +177,50 @@ These options are for Jeweler
 * Help
   * please use help $ biogem -h to discover other options for creating rspec or cucumber tests
 
- Toshiaki Katayama wrote a step by step guide for a bio-foobar plugin @ http://bioruby.open-bio.org/wiki/BiogemInstallation.
+=== DataBaseConnection
+Is a best practices, at least for me, to have a dummy class which establishes the connection with the database and inherit that class by the models. The benefit of this approach is to have multiple connections available at the same time in case you are developing/using multiple gems with different databases. This file is located in lib/bio/kb
+
+    module Bio
+	  module KB
+	    class DummyMySpecialDB < ActiveRecord::Base
+	      self.abstract_class = true
+	      establish_connection(:adapter =>'sqlite3',:database =>"#{File.dirname(__FILE__)}/../../../db/yourdb.sqlite3")
+	    end
+	  end
+	end
+	
+or you can use the configuration file db/database.yml and add this code to the module above. Note I don't like very much to add every time this code so in a future release I'll find out a way to add it automatically, probably overwriting the configurations call.
+
+	root_path = File.join(File.dirname(__FILE__),"../../../")
+    configurations = YAML.load_file(File.join(root_path,"conf/database.yml"))
+    configurations.each_pair do |key, db_info|
+      db_info["database"] = File.join(root_path, db_info["database"]) if db_info["adapter"]=='sqlite3'
+    end
+    establish_connection(configurations["default"])
+
+This code is necessary because the db is inside the gem and you can't know where the file will be installed ( using the YAML config file.)
+
+The model must be located in a directory structure like lib/bio/kb/yourclass this is important because ActiveRecord can map the namespace with the directory tree.
+
+    module Bio
+	  module KB
+	      module MySpecialDB
+	         class Mytable < Bio::KB::DummyMySpecialDB
+	         end
+	      end
+	  end
+	end
+
+=== Seeds
+Before populate you seeds.rb file you must declare a model. The model is declared in the usual Rails' way, see above.
+
+	 #Use this file to load a default dataset into your database
+	 %w(Raoul Toshiaki Francesco).each do |coder|
+	   Bio::KB::MySpecialDB::Example.create(:name=>coder, :tag=>"bioruby", :type=>"developer")
+	 end
+
+=== StepByStep
+Toshiaki Katayama wrote a step by step guide for a bio-foobar plugin @ http://bioruby.open-bio.org/wiki/BiogemInstallation.
 
 == BioRuby's Wiki Official Documentation
 

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.0

data/bio-gem.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bio-gem}
-  s.version = "0.2.2"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Raoul J.P. Bonnal"]
-  s.date = %q{2011-02-09}
+  s.date = %q{2011-08-05}
   s.default_executable = %q{biogem}
   s.description = %q{BioGem is a scaffold generator for those Bioinformaticans who want to start coding an application or a library for using/extending BioRuby core library and sharing it through rubygems.org .
   The basic idea is to simplify and promote a modular approach to the BioRuby package.}
@@ -35,13 +35,18 @@ Gem::Specification.new do |s|
     "lib/bio-gem/mod/jeweler/github_mixin.rb",
     "lib/bio-gem/mod/jeweler/options.rb",
     "lib/bio-gem/templates/bin",
+    "lib/bio-gem/templates/database",
+    "lib/bio-gem/templates/lib",
+    "lib/bio-gem/templates/migration",
+    "lib/bio-gem/templates/rakefile",
+    "lib/bio-gem/templates/seeds",
     "test/helper.rb",
     "test/test_bio-gem.rb"
   ]
   s.homepage = %q{http://github.com/helios/bioruby-gem}
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
+  s.rubygems_version = %q{1.5.0}
   s.summary = %q{BioGem helps Bioinformaticians start developing plugins/modules for BioRuby creating a scaffold and a gem package}
   s.test_files = [
     "test/helper.rb",
@@ -49,7 +54,6 @@ Gem::Specification.new do |s|
   ]
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then

data/lib/bio-gem/mod/jeweler.rb

@@ -9,13 +9,23 @@ class Jeweler
     alias original_initialize initialize
     def initialize(options = {})
       original_initialize(options)
-      development_dependencies  << ["bio", ">= 1.4.1"]
+      development_dependencies << ["bio", ">= 1.4.1"]
+      if options[:biogem_db]
+        development_dependencies << ["activerecord", ">= 3.0.7"]
+        development_dependencies << ["activesupport", ">= 3.0.7"]
+        development_dependencies << ["sqlite3", ">= 1.3.3"]
+      end
     end
 
     alias original_project_name project_name  
     def project_name
       "bio-#{original_project_name}"
     end
+
+    def lib_dir
+      'lib'
+    end
+
     def lib_filename
       "#{project_name}.rb"
     end
@@ -53,37 +63,70 @@ class Jeweler
       template.result(binding).gsub(/\n\n\n+/, "\n\n")
     end
 
-    def output_template_in_target_generic(source, destination = source, template_dir = template_dir_biogem)
+    def output_template_in_target_generic(source, destination = source, template_dir = template_dir_biogem, write_type='w')
       final_destination = File.join(target_dir, destination)
       template_result   = render_template_generic(source, template_dir)
 
-      File.open(final_destination, 'w') {|file| file.write(template_result)}
-
-      $stdout.puts "\tcreate\t#{destination}"
+      File.open(final_destination, write_type) {|file| file.write(template_result)}
+      status = case write_type
+      when 'w' then 'create'
+      when 'a' then 'update'
+      end
+      $stdout.puts "\t#{status}\t#{destination}"
     end
 
     def template_dir_biogem
       File.join(File.dirname(__FILE__),'..', 'templates')
     end
 
+
+    def create_db_structure
+      migrate_dir = File.join(db_dir, "migrate")
+      mkdir_in_target(db_dir)
+      mkdir_in_target(migrate_dir)
+      mkdir_in_target("conf")
+      output_template_in_target_generic 'database', File.join("conf", "database.yml")
+      output_template_in_target_generic 'migration', File.join(migrate_dir, "001_create_example.rb" )
+      output_template_in_target_generic 'seeds', File.join(db_dir, "seeds.rb")
+      output_template_in_target_generic 'rakefile', 'Rakefile', template_dir_biogem, 'a' #need to spec all the option to enable the append option
+    end
+
     alias original_create_files create_files
-    # this is the defaul directory for storing library datasets
+    # this is the default directory for storing library datasets
     # creates a data directory for every needs.
     #the options are defined in mod/jeweler/options.rb
     def create_files
-      original_create_files
-      
-      if options[:biogem_test_data]
-        mkdir_in_target("test") unless File.exists? "#{target_dir}/test"
-        mkdir_in_target test_data_dir  
-      end
-      mkdir_in_target(db_dir) if options[:biogem_db]
-      if options[:biogem_bin] 
-        mkdir_in_target bin_dir
-        output_template_in_target_generic 'bin', File.join(bin_dir, bin_name)
-        # TODO: set the file as executable
-        File.chmod 0655, File.join(target_dir, bin_dir, bin_name)
-      end
+      if options[:biogem_meta]
+        unless File.exists?(target_dir) || File.directory?(target_dir)
+          FileUtils.mkdir target_dir
+        else
+          raise FileInTheWay, "The directory #{target_dir} already exists, aborting. Maybe move it out of the way before continuing?"
+        end
+        
+        output_template_in_target '.gitignore'
+        output_template_in_target 'Rakefile'
+        output_template_in_target 'Gemfile'  if should_use_bundler
+        output_template_in_target 'LICENSE.txt'
+        output_template_in_target 'README.rdoc'
+        output_template_in_target '.document'
+      else
+        original_create_files
+
+        if options[:biogem_test_data]
+          mkdir_in_target("test") unless File.exists? "#{target_dir}/test"
+          mkdir_in_target test_data_dir  
+        end
+        create_db_structure if options[:biogem_db]
+        if options[:biogem_bin] 
+          mkdir_in_target bin_dir
+          output_template_in_target_generic 'bin', File.join(bin_dir, bin_name)
+          # TODO: set the file as executable
+          File.chmod 0655, File.join(target_dir, bin_dir, bin_name)
+        end
+
+        # Fill lib/bio-plugin.rb with some default comments
+        output_template_in_target_generic 'lib', File.join(lib_dir, lib_filename)
+      end #not_bio_gem_meta
     end
 
     def create_and_push_repo

data/lib/bio-gem/mod/jeweler/options.rb

@@ -33,7 +33,13 @@ class Jeweler
           
           o.separator "These options are for BioGem"
           
-          #TODO: Scrivere le altre opzioni          
+          #TODO: Scrivere le altre opzioni
+          
+          #Note this option has the priority over all the other options.
+          o.on("--meta", 'create a meta package, just the Rakefile, Gemfile, Licence, Readme. This options takes the precedence over every other option.') do
+            self[:biogem_meta] = true
+          end
+          
           o.on("--with-bin", 'create the bin directory and an executable template script called bioreponame') do
             self[:biogem_bin] = true
           end

data/lib/bio-gem/templates/database

@@ -0,0 +1,7 @@
+# SQLite version 3.x
+# gem install sqlite3
+default:
+  adapter: sqlite3
+  database: db/<%= project_name %>.sqlite3
+  pool: 5
+  timeout: 5000

data/lib/bio-gem/templates/lib

@@ -0,0 +1,10 @@
+# Please require your code below, respecting the bioruby directory tree. 
+# For instance, perhaps the only uncommented line in this file might 
+# be something like this:
+#
+#   require 'bio/sequence/awesome_sequence_plugin_thingy'
+#
+# and then create the ruby file 'lib/bio/sequence/awesome_sequence_thingy.rb'
+# and put your plugin's code there. It is bad practice to write other code 
+# directly into this file, because doing so causes confusion if this biogem 
+# was ever to get merged into the main bioruby tree.

data/lib/bio-gem/templates/migration

@@ -0,0 +1,20 @@
+# # The code below create a table name example
+# # As best practice name this file with a prefix index like 001_create_example.rb and the next migration 002.... and so on, this will help you to keep track over the time.
+# # Please refer to Rails' documentation
+#
+# class CreateExample < ActiveRecord::Migration
+#   def self.up
+#     #primary key id is created automatically by ActiveRecord::Migration
+#     create_table :example do |t|
+#       t.string :name
+#       t.string :tag
+#       t.string :type
+#     end
+# 
+#     add_index :example, :name
+#   end
+# 
+#   def self.down
+#     drop_table :example
+#   end
+# end

data/lib/bio-gem/templates/rakefile

@@ -0,0 +1,524 @@
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__),'lib')
+require 'active_support'
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/module/delegation'
+require 'active_record'
+
+#This code is coming from activerecord-3.0.7/lib/active_record/railties/databases.rake
+namespace :db do
+  task :load_config do
+    require 'active_record'
+    ActiveRecord::Base.configurations = YAML.load_file("conf/database.yml")
+  end
+
+  task :environment => :load_config do
+    ActiveRecord::Base.establish_connection('default')
+  end
+
+  namespace :create do
+    # desc 'Create all the local databases defined in config/database.yml'
+    task :all => :load_config do
+      ActiveRecord::Base.configurations.each_value do |config|
+        # Skip entries that don't have a database key, such as the first entry here:
+        #
+        #  defaults: &defaults
+        #    adapter: mysql
+        #    username: root
+        #    password:
+        #    host: localhost
+        #
+        #  development:
+        #    database: blog_development
+        #    <<: *defaults
+        next unless config['database']
+        # Only connect to local databases
+        local_database?(config) { create_database(config) }
+      end
+    end
+  end
+
+  desc 'Create the database from config/database.yml for the current default (use db:create:all to create all dbs in the config)'
+  task :create => :load_config do
+    # Make the test database at the same time as the development one, if it exists
+#    if 'default'.development? && ActiveRecord::Base.configurations['test']
+      create_database(ActiveRecord::Base.configurations['default'])
+#    end
+#    create_database(ActiveRecord::Base.configurations['default'])
+  end
+
+  def create_database(config)
+    begin
+      if config['adapter'] =~ /sqlite/
+        if File.exist?(config['database'])
+          $stderr.puts "#{config['database']} already exists"
+        else
+          begin
+            # Create the SQLite database
+            ActiveRecord::Base.establish_connection(config)
+            ActiveRecord::Base.connection
+          rescue Exception => e
+            $stderr.puts e, *(e.backtrace)
+            $stderr.puts "Couldn't create database for #{config.inspect}"
+          end
+        end
+        return # Skip the else clause of begin/rescue
+      else
+        ActiveRecord::Base.establish_connection(config)
+        ActiveRecord::Base.connection
+      end
+    rescue
+      case config['adapter']
+      when /mysql/
+        @charset   = ENV['CHARSET']   || 'utf8'
+        @collation = ENV['COLLATION'] || 'utf8_unicode_ci'
+        creation_options = {:charset => (config['charset'] || @charset), :collation => (config['collation'] || @collation)}
+        error_class = config['adapter'] =~ /mysql2/ ? Mysql2::Error : Mysql::Error
+        access_denied_error = 1045
+        begin
+          ActiveRecord::Base.establish_connection(config.merge('database' => nil))
+          ActiveRecord::Base.connection.create_database(config['database'], creation_options)
+          ActiveRecord::Base.establish_connection(config)
+        rescue error_class => sqlerr
+          if sqlerr.errno == access_denied_error
+            print "#{sqlerr.error}. \nPlease provide the root password for your mysql installation\n>"
+            root_password = $stdin.gets.strip
+            grant_statement = "GRANT ALL PRIVILEGES ON #{config['database']}.* " \
+              "TO '#{config['username']}'@'localhost' " \
+              "IDENTIFIED BY '#{config['password']}' WITH GRANT OPTION;"
+            ActiveRecord::Base.establish_connection(config.merge(
+                'database' => nil, 'username' => 'root', 'password' => root_password))
+            ActiveRecord::Base.connection.create_database(config['database'], creation_options)
+            ActiveRecord::Base.connection.execute grant_statement
+            ActiveRecord::Base.establish_connection(config)
+          else
+            $stderr.puts sqlerr.error
+            $stderr.puts "Couldn't create database for #{config.inspect}, charset: #{config['charset'] || @charset}, collation: #{config['collation'] || @collation}"
+            $stderr.puts "(if you set the charset manually, make sure you have a matching collation)" if config['charset']
+          end
+        end
+      when 'postgresql'
+        @encoding = config['encoding'] || ENV['CHARSET'] || 'utf8'
+        begin
+          ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+          ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => @encoding))
+          ActiveRecord::Base.establish_connection(config)
+        rescue Exception => e
+          $stderr.puts e, *(e.backtrace)
+          $stderr.puts "Couldn't create database for #{config.inspect}"
+        end
+      end
+    else
+      $stderr.puts "#{config['database']} already exists"
+    end
+  end
+
+  namespace :drop do
+    # desc 'Drops all the local databases defined in config/database.yml'
+    task :all => :load_config do
+      ActiveRecord::Base.configurations.each_value do |config|
+        # Skip entries that don't have a database key
+        next unless config['database']
+        begin
+          # Only connect to local databases
+          local_database?(config) { drop_database(config) }
+        rescue Exception => e
+          $stderr.puts "Couldn't drop #{config['database']} : #{e.inspect}"
+        end
+      end
+    end
+  end
+
+  desc 'Drops the database for the current default (use db:drop:all to drop all databases)'
+  task :drop => :load_config do
+    config = ActiveRecord::Base.configurations['default' || 'development']
+    begin
+      drop_database(config)
+    rescue Exception => e
+      $stderr.puts "Couldn't drop #{config['database']} : #{e.inspect}"
+    end
+  end
+
+  def local_database?(config, &block)
+    if %w( 127.0.0.1 localhost ).include?(config['host']) || config['host'].blank?
+      yield
+    else
+      $stderr.puts "This task only modifies local databases. #{config['database']} is on a remote host."
+    end
+  end
+
+
+  desc "Migrate the database (options: VERSION=x, VERBOSE=false)."
+  task :migrate => :environment do
+    ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+    ActiveRecord::Migrator.migrate("db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+  end
+
+  namespace :migrate do
+    # desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
+    task :redo => :environment do
+      if ENV["VERSION"]
+        Rake::Task["db:migrate:down"].invoke
+        Rake::Task["db:migrate:up"].invoke
+      else
+        Rake::Task["db:rollback"].invoke
+        Rake::Task["db:migrate"].invoke
+      end
+    end
+
+    # desc 'Resets your database using your migrations for the current environment'
+    task :reset => ["db:drop", "db:create", "db:migrate"]
+
+    # desc 'Runs the "up" for a given migration VERSION.'
+    task :up => :environment do
+      version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+      raise "VERSION is required" unless version
+      ActiveRecord::Migrator.run(:up, "db/migrate/", version)
+      Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+    end
+
+    # desc 'Runs the "down" for a given migration VERSION.'
+    task :down => :environment do
+      version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+      raise "VERSION is required" unless version
+      ActiveRecord::Migrator.run(:down, "db/migrate/", version)
+      Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+    end
+
+    desc "Display status of migrations"
+    task :status => :environment do
+      config = ActiveRecord::Base.configurations['default']
+      ActiveRecord::Base.establish_connection(config)
+      unless ActiveRecord::Base.connection.table_exists?(ActiveRecord::Migrator.schema_migrations_table_name)
+        puts 'Schema migrations table does not exist yet.'
+        next  # means "return" for rake task
+      end
+      db_list = ActiveRecord::Base.connection.select_values("SELECT version FROM #{ActiveRecord::Migrator.schema_migrations_table_name}")
+      file_list = []
+      Dir.foreach(File.join('db', 'migrate')) do |file|
+        # only files matching "20091231235959_some_name.rb" pattern
+        if match_data = /(\d{14})_(.+)\.rb/.match(file)
+          status = db_list.delete(match_data[1]) ? 'up' : 'down'
+          file_list << [status, match_data[1], match_data[2]]
+        end
+      end
+      # output
+      puts "\ndatabase: #{config['database']}\n\n"
+      puts "#{"Status".center(8)}  #{"Migration ID".ljust(14)}  Migration Name"
+      puts "-" * 50
+      file_list.each do |file|
+        puts "#{file[0].center(8)}  #{file[1].ljust(14)}  #{file[2].humanize}"
+      end
+      db_list.each do |version|
+        puts "#{'up'.center(8)}  #{version.ljust(14)}  *** NO FILE ***"
+      end
+      puts
+    end
+  end
+
+  desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n).'
+  task :rollback => :environment do
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+    ActiveRecord::Migrator.rollback('db/migrate/', step)
+    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+  end
+
+  # desc 'Pushes the schema to the next version (specify steps w/ STEP=n).'
+  task :forward => :environment do
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+    ActiveRecord::Migrator.forward('db/migrate/', step)
+    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+  end
+
+  # desc 'Drops and recreates the database from db/schema.rb for the current environment and loads the seeds.'
+  task :reset => [ 'db:drop', 'db:setup' ]
+
+  # desc "Retrieves the charset for the current environment's database"
+  task :charset => :environment do
+    config = ActiveRecord::Base.configurations['default' || 'development']
+    case config['adapter']
+    when /mysql/
+      ActiveRecord::Base.establish_connection(config)
+      puts ActiveRecord::Base.connection.charset
+    when 'postgresql'
+      ActiveRecord::Base.establish_connection(config)
+      puts ActiveRecord::Base.connection.encoding
+    when 'sqlite3'
+      ActiveRecord::Base.establish_connection(config)
+      puts ActiveRecord::Base.connection.encoding
+    else
+      $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+    end
+  end
+
+  # desc "Retrieves the collation for the current environment's database"
+  task :collation => :environment do
+    config = ActiveRecord::Base.configurations['default']
+    case config['adapter']
+    when /mysql/
+      ActiveRecord::Base.establish_connection(config)
+      puts ActiveRecord::Base.connection.collation
+    else
+      $stderr.puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+    end
+  end
+
+  desc "Retrieves the current schema version number"
+  task :version => :environment do
+    puts "Current version: #{ActiveRecord::Migrator.current_version}"
+  end
+
+  # desc "Raises an error if there are pending migrations"
+  task :abort_if_pending_migrations => :environment do
+    if defined? ActiveRecord
+      pending_migrations = ActiveRecord::Migrator.new(:up, 'db/migrate').pending_migrations
+
+      if pending_migrations.any?
+        puts "You have #{pending_migrations.size} pending migrations:"
+        pending_migrations.each do |pending_migration|
+          puts '  %4d %s' % [pending_migration.version, pending_migration.name]
+        end
+        abort %{Run "rake db:migrate" to update your database then try again.}
+      end
+    end
+  end
+
+  desc 'Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the db first)'
+  task :setup => [ 'db:create', 'db:schema:load', 'db:seed' ]
+
+  desc 'Load the seed data from db/seeds.rb'
+  task :seed => 'db:abort_if_pending_migrations' do
+    seed_file = File.join('db', 'seeds.rb')
+    load(seed_file) if File.exist?(seed_file)
+  end
+
+  namespace :fixtures do
+    desc "Load fixtures into the current environment's database.  Load specific fixtures using FIXTURES=x,y. Load from subdirectory in test/fixtures using FIXTURES_DIR=z. Specify an alternative path (eg. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
+    task :load => :environment do
+      require 'active_record/fixtures'
+
+      ActiveRecord::Base.establish_connection('default')
+      base_dir = ENV['FIXTURES_PATH'] ? File.join(ENV['FIXTURES_PATH']) : File.join('test', 'fixtures')
+      fixtures_dir = ENV['FIXTURES_DIR'] ? File.join(base_dir, ENV['FIXTURES_DIR']) : base_dir
+
+      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/).map {|f| File.join(fixtures_dir, f) } : Dir["#{fixtures_dir}/**/*.{yml,csv}"]).each do |fixture_file|
+        Fixtures.create_fixtures(fixtures_dir, fixture_file[(fixtures_dir.size + 1)..-5])
+      end
+    end
+
+    # desc "Search for a fixture given a LABEL or ID. Specify an alternative path (eg. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
+    task :identify => :environment do
+      require 'active_record/fixtures'
+
+      label, id = ENV["LABEL"], ENV["ID"]
+      raise "LABEL or ID required" if label.blank? && id.blank?
+
+      puts %Q(The fixture ID for "#{label}" is #{Fixtures.identify(label)}.) if label
+
+      base_dir = ENV['FIXTURES_PATH'] ? File.join(ENV['FIXTURES_PATH']) : File.join('test', 'fixtures')
+      Dir["#{base_dir}/**/*.yml"].each do |file|
+        if data = YAML::load(ERB.new(IO.read(file)).result)
+          data.keys.each do |key|
+            key_id = Fixtures.identify(key)
+
+            if key == label || key_id == id.to_i
+              puts "#{file}: #{key} (#{key_id})"
+            end
+          end
+        end
+      end
+    end
+  end
+
+  namespace :schema do
+    desc "Create a db/schema.rb file that can be portably used against any DB supported by AR"
+    task :dump => :environment do
+      require 'active_record/schema_dumper'
+      File.open(ENV['SCHEMA'] || "db/schema.rb", "w") do |file|
+        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+      end
+      Rake::Task["db:schema:dump"].reenable
+    end
+
+    desc "Load a schema.rb file into the database"
+    task :load => :environment do
+      file = ENV['SCHEMA'] || "db/schema.rb"
+      if File.exists?(file)
+        load(file)
+      else
+        abort %{#{file} doesn't exist yet. Run "rake db:migrate" to create it then try again. If you do not intend to use a database, you should instead alter config/application.rb to limit the frameworks that will be loaded}
+      end
+    end
+  end
+
+  namespace :structure do
+    desc "Dump the database structure to an SQL file"
+    task :dump => :environment do
+      abcs = ActiveRecord::Base.configurations
+      case abcs['default']["adapter"]
+      when /mysql/, "oci", "oracle"
+        ActiveRecord::Base.establish_connection(abcs['default'])
+        File.open("db/#{'default'}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
+      when "postgresql"
+        ENV['PGHOST']     = abcs['default']["host"] if abcs['default']["host"]
+        ENV['PGPORT']     = abcs['default']["port"].to_s if abcs['default']["port"]
+        ENV['PGPASSWORD'] = abcs['default']["password"].to_s if abcs['default']["password"]
+        search_path = abcs['default']["schema_search_path"]
+        unless search_path.blank?
+          search_path = search_path.split(",").map{|search_path| "--schema=#{search_path.strip}" }.join(" ")
+        end
+        `pg_dump -i -U "#{abcs['default']["username"]}" -s -x -O -f db/default_structure.sql #{search_path} #{abcs['default']["database"]}`
+        raise "Error dumping database" if $?.exitstatus == 1
+      when "sqlite", "sqlite3"
+        dbfile = abcs['default']["database"] || abcs['default']["dbfile"]
+        `#{abcs['default']["adapter"]} #{dbfile} .schema > db/#{'default'}_structure.sql`
+      when "sqlserver"
+        `scptxfr /s #{abcs['default']["host"]} /d #{abcs['default']["database"]} /I /f db\\#{'default'}_structure.sql /q /A /r`
+        `scptxfr /s #{abcs['default']["host"]} /d #{abcs['default']["database"]} /I /F db\ /q /A /r`
+      when "firebird"
+        set_firebird_env(abcs['default'])
+        db_string = firebird_db_string(abcs['default'])
+        sh "isql -a #{db_string} > db/#{'default'}_structure.sql"
+      else
+        raise "Task not supported by '#{abcs['default']["adapter"]}'"
+      end
+
+      if ActiveRecord::Base.connection.supports_migrations?
+        File.open("db/#{'default'}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+      end
+    end
+  end
+
+  namespace :test do
+    # desc "Recreate the test database from the current schema.rb"
+    task :load => 'db:test:purge' do
+      ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
+      ActiveRecord::Schema.verbose = false
+      Rake::Task["db:schema:load"].invoke
+    end
+
+    # desc "Recreate the test database from the current environment's database schema"
+    task :clone => %w(db:schema:dump db:test:load)
+
+    # desc "Recreate the test databases from the development structure"
+    task :clone_structure => [ "db:structure:dump", "db:test:purge" ] do
+      abcs = ActiveRecord::Base.configurations
+      case abcs["test"]["adapter"]
+      when /mysql/
+        ActiveRecord::Base.establish_connection(:test)
+        ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
+        IO.readlines("db/#{'default'}_structure.sql").join.split("\n\n").each do |table|
+          ActiveRecord::Base.connection.execute(table)
+        end
+      when "postgresql"
+        ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
+        ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
+        ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
+        `psql -U "#{abcs["test"]["username"]}" -f db/#{'default'}_structure.sql #{abcs["test"]["database"]}`
+      when "sqlite", "sqlite3"
+        dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
+        `#{abcs["test"]["adapter"]} #{dbfile} < db/#{'default'}_structure.sql`
+      when "sqlserver"
+        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{'default'}_structure.sql`
+      when "oci", "oracle"
+        ActiveRecord::Base.establish_connection(:test)
+        IO.readlines("db/#{'default'}_structure.sql").join.split(";\n\n").each do |ddl|
+          ActiveRecord::Base.connection.execute(ddl)
+        end
+      when "firebird"
+        set_firebird_env(abcs["test"])
+        db_string = firebird_db_string(abcs["test"])
+        sh "isql -i db/#{'default'}_structure.sql #{db_string}"
+      else
+        raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+      end
+    end
+
+    # desc "Empty the test database"
+    task :purge => :environment do
+      abcs = ActiveRecord::Base.configurations
+      case abcs["test"]["adapter"]
+      when /mysql/
+        ActiveRecord::Base.establish_connection(:test)
+        ActiveRecord::Base.connection.recreate_database(abcs["test"]["database"], abcs["test"])
+      when "postgresql"
+        ActiveRecord::Base.clear_active_connections!
+        drop_database(abcs['test'])
+        create_database(abcs['test'])
+      when "sqlite","sqlite3"
+        dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
+        File.delete(dbfile) if File.exist?(dbfile)
+      when "sqlserver"
+        dropfkscript = "#{abcs["test"]["host"]}.#{abcs["test"]["database"]}.DP1".gsub(/\\/,'-')
+        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{dropfkscript}`
+        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{'default'}_structure.sql`
+      when "oci", "oracle"
+        ActiveRecord::Base.establish_connection(:test)
+        ActiveRecord::Base.connection.structure_drop.split(";\n\n").each do |ddl|
+          ActiveRecord::Base.connection.execute(ddl)
+        end
+      when "firebird"
+        ActiveRecord::Base.establish_connection(:test)
+        ActiveRecord::Base.connection.recreate_database!
+      else
+        raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+      end
+    end
+
+    # desc 'Check for pending migrations and load the test schema'
+    task :prepare => 'db:abort_if_pending_migrations' do
+      if defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
+        Rake::Task[{ :sql  => "db:test:clone_structure", :ruby => "db:test:load" }[ActiveRecord::Base.schema_format]].invoke
+      end
+    end
+  end
+
+  namespace :sessions do
+    # desc "Creates a sessions migration for use with ActiveRecord::SessionStore"
+    task :create => :environment do
+      raise "Task unavailable to this database (no migration support)" unless ActiveRecord::Base.connection.supports_migrations?
+      require 'rails/generators'
+      Rails::Generators.configure!
+      require 'rails/generators/rails/session_migration/session_migration_generator'
+      Rails::Generators::SessionMigrationGenerator.start [ ENV["MIGRATION"] || "add_sessions_table" ]
+    end
+
+    # desc "Clear the sessions table"
+    task :clear => :environment do
+      ActiveRecord::Base.connection.execute "DELETE FROM #{session_table_name}"
+    end
+  end
+end
+
+task 'test:prepare' => 'db:test:prepare'
+
+def drop_database(config)
+  case config['adapter']
+  when /mysql/
+    ActiveRecord::Base.establish_connection(config)
+    ActiveRecord::Base.connection.drop_database config['database']
+  when /^sqlite/
+    require 'pathname'
+    path = Pathname.new(config['database'])
+    file = path.absolute? ? path.to_s : File.join( path)
+
+    FileUtils.rm(file)
+  when 'postgresql'
+    ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+    ActiveRecord::Base.connection.drop_database config['database']
+  end
+end
+
+def session_table_name
+  ActiveRecord::SessionStore::Session.table_name
+end
+
+def set_firebird_env(config)
+  ENV["ISC_USER"]     = config["username"].to_s if config["username"]
+  ENV["ISC_PASSWORD"] = config["password"].to_s if config["password"]
+end
+
+def firebird_db_string(config)
+  FireRuby::Database.db_string_for(config.symbolize_keys)
+end

data/lib/bio-gem/templates/seeds

@@ -0,0 +1,12 @@
+#require '<%= project_name %>'
+# # NOTE: You must define your model somewhere in your library
+# #       and you must keep in mind that if you decide to have
+# #       MultilabelNamespace you must create the right directory
+# #       structure for it:
+# #       Suppose Bio::Project::Mymodel < ActiveRecord::Base or a dummy class with the connection.
+# #       Checkout the documentation.
+# #       bioruby-gem/lib/bio/project/mymodel.rb
+# #Use this file to load a default dataset into your database
+# %w(Raoul Toshiaki Francesco).each do |coder|
+#  YourNameSpace Example.create(:name=>coder, :tag=>"bioruby", :type=>"developer")
+# end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: bio-gem
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 2
-  version: 0.2.2
+  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors: 
 - Raoul J.P. Bonnal
@@ -14,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-09 00:00:00 +01:00
+date: 2011-08-05 00:00:00 +02:00
 default_executable: biogem
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -24,8 +20,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
   prerelease: false
@@ -37,10 +31,6 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 0
-        - 0
         version: 1.0.0
   type: :development
   prerelease: false
@@ -52,10 +42,6 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 5
-        - 1
         version: 1.5.1
   type: :development
   prerelease: false
@@ -67,8 +53,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
   prerelease: false
@@ -100,6 +84,11 @@ files:
 - lib/bio-gem/mod/jeweler/github_mixin.rb
 - lib/bio-gem/mod/jeweler/options.rb
 - lib/bio-gem/templates/bin
+- lib/bio-gem/templates/database
+- lib/bio-gem/templates/lib
+- lib/bio-gem/templates/migration
+- lib/bio-gem/templates/rakefile
+- lib/bio-gem/templates/seeds
 - test/helper.rb
 - test/test_bio-gem.rb
 has_rdoc: true
@@ -116,7 +105,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3133852585344624584
+      hash: -1492955173838724395
       segments: 
       - 0
       version: "0"
@@ -125,13 +114,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.5.0
 signing_key: 
 specification_version: 3
 summary: BioGem helps Bioinformaticians start developing plugins/modules for BioRuby creating a scaffold and a gem package