bio-gem 1.2.1 → 1.2.2

data/Gemfile

@@ -3,7 +3,7 @@ source "http://rubygems.org"
 # Example:
 #   gem "activesupport", ">= 2.3.5"
 gem "bundler", "~> 1.0.18"
-gem "jeweler", "~> 1.6.4"
+gem "jeweler", ">= 1.7.0"
 gem "rdoc"
 
 
@@ -12,7 +12,6 @@ gem "rdoc"
 group :development do
   gem "shoulda", ">= 0"
   gem "bundler", "~> 1.0.18"
-  gem "jeweler", "~> 1.6.4"
-  gem "rcov", ">= 0"
+  gem "jeweler", ">= 1.7.0"
   gem "rdoc"
 end

data/Gemfile.lock

@@ -2,13 +2,13 @@ GEM
   remote: http://rubygems.org/
   specs:
     git (1.2.5)
-    jeweler (1.6.4)
+    jeweler (1.7.0)
       bundler (~> 1.0)
       git (>= 1.2.5)
       rake
+      rdoc
     json (1.6.4)
     rake (0.9.2.2)
-    rcov (0.9.11)
     rdoc (3.12)
       json (~> 1.4)
     shoulda (2.11.3)
@@ -18,7 +18,6 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 1.0.18)
-  jeweler (~> 1.6.4)
-  rcov
+  jeweler (>= 1.7.0)
   rdoc
   shoulda

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Raoul J.P. Bonnal
+Copyright (c) 2010-2012 Raoul J.P. Bonnal
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -21,11 +21,15 @@ versioning, releasing it to github.com and/or rubygems.org and
 packaging. Bundler is used used for setting up a predefined developing
 environment.
 
-Also Biogem makes use of webservices. E.g.
+Also Biogem makes use of webservices. Currently
 
-* GitHub.com and RubyGems.org
-  are two different services and you need to create different accounts for them
-  if you already use GitHub.com you are set for using Biogem
+* GitHub.com 
+  is used for maintaining the source tree, tracking changes and
+  issues. Create a github account if you don't have one.
+* RubyGems.org
+  publishes your software for other people to install and use
+* biogems.info
+  tracks all biogems, so people can find them
 
 == Installation
 
@@ -45,8 +49,12 @@ Also Biogem makes use of webservices. E.g.
    $ git config --global github.token "TOKEN ASSIGNED BY GITHUB"
 
 Note: another Ruby version management system used in BioRuby community is https://github.com/sstephenson/rbenv but for now we can not provide support for it.
+
 ==== IMPORTANT NOTE
-Rubygems will not let you install Biogem in an environment with a Ruby interpreter older than 1.9.X
+
+Rubygems will not let you install Biogem in an environment with a Ruby
+interpreter older than 1.9.X. Biogem can create gems for Ruby 1.8.7 -
+but you need a recent version of Ruby and tools to run Biogem itself.
 
 === Download
 
@@ -95,6 +103,7 @@ Note: the above list of dependencies is just an example and it may vary from you
 
 During the installation you may note how Rubygems install the documentation for you, for each library installed.
 Is possible to access to all the documentations and API installed simply typing in the command line:
+
     $ gem server
 	Server started at http://0.0.0.0:8808
 	Server started at http://[::ffff:0.0.0.0]:8808
@@ -107,10 +116,12 @@ Note: the above link must be update with your current version of Biogem
 == Biogem Tutorial HowTo Develop a plugins
 
 Please follow the guide reported in tutorial https://github.com/helios/bioruby-gem/blob/master/Tutorial.rdoc, which is the most up to date version.
-You'll find out how to create:
+You'll find out how to create
+
 * a simple plugin
 * embed a database
 * create a Biogem Engine to embed your gem into a Ruby on Rails web application
+
 and much more
 
 
@@ -121,11 +132,13 @@ and much more
 == Contributing to Biogem
 
 The source code repositories for Biogem and http://biogems.info
-website are on github.
+website are on github
+
 * https://github.com/helios/bioruby-gem
 * https://github.com/pjotrp/biogems.info
-If you want to contribute, feel free! Clone the
-project!
+
+Use Biogem for all purposes DRY. If you want to contribute, feel free! Clone the
+project! Submit! Send us a pull request!
 
 == BioRuby's Wiki Official Documentation
 
@@ -171,9 +184,13 @@ e.g. biogem the-perfect-gem
         --rdoc                       use rdoc for documentation
     -h, --help                       display this help and exit
 
+Recent versions of Biogem may have more options. For a full list run
+
+    bundle exec rake -T
+
 == Copyright
 
-Copyright (c) 2010, 2011 Raoul J.P. Bonnal. See LICENSE.txt for
+Copyright (c) 2010-2012 Raoul J.P. Bonnal. See LICENSE.txt for
 further details.
 
 

data/Rakefile

@@ -15,11 +15,11 @@ Jeweler::Tasks.new do |gem|
   gem.name = "bio-gem"
   gem.homepage = "http://github.com/helios/bioruby-gem"
   gem.license = "MIT"
-  gem.summary = %Q{BioGem helps Bioinformaticians start developing plugins/modules for BioRuby creating a scaffold and a gem package}
-  gem.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.}
+  gem.summary = %Q{Biogem is a software generator for Ruby in bioinformatics}
+  gem.description = %Q{Biogem is a software 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 bioinformatics software development}
   gem.email = "ilpuccio.febo@gmail.com"
-  gem.authors = ["Raoul J.P. Bonnal"]
+  gem.authors = ["Raoul J.P. Bonnal", "Pjotr Prins"]
   # Include your dependencies below. Runtime dependencies are required when using your gem,
   # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
   #gem.version='0.0.1'
@@ -46,12 +46,14 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-require 'rcov/rcovtask'
-Rcov::RcovTask.new do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
+# No proper rcov support in 1.9
+#
+# require 'rcov/rcovtask'
+# Rcov::RcovTask.new do |test|
+#   test.libs << 'test'
+#   test.pattern = 'test/**/test_*.rb'
+#   test.verbose = true
+# end
 
 task :default => :test
 

data/Tutorial.rdoc

@@ -41,7 +41,7 @@ In case you are not connected to internet the following message will appear:
 
 Note the name of the plugin is important. Plugins are published as Ruby gems on http://rubygems.org/. All plugins that start with the name bio dash (bio-) are automatically listed on the Biogem website http://biogems.info/ !
 
-The first step is to open Rakefile and modify the gem.summary and gem.description.
+The first step is to open the Rakefile and modify the gem.summary and gem.description.
 
   gem.summary = %Q{TODO: one-line summary of your gem}
   gem.description = %Q{TODO: longer description of your gem}
@@ -402,11 +402,11 @@ Biogem, like other frameworks, offers a bunch of predefined and common operation
 
    $ rake -T 
 
-but because we are in a "development environment" is strongly suggested to use a very similar command 
+but because we are in a "development environment" we suggest to use
 
    $ bundle exec rake -T
 
-which guarantees that all the called programs/tasks will be executed inside the current development environment (bound to specific libraries versions). Follows the list of all available tasks for Biogem
+which guarantees that all the called programs/tasks will be executed inside the current development environment (bound to specific libraries versions). rake -T displays the list of tasks
 
     rake build               # Build gem into pkg/
     rake clobber_rcov        # Remove rcov products for rcov
@@ -443,7 +443,6 @@ which guarantees that all the called programs/tasks will be executed inside the
     rake version:bump:patch  # Bump the patch version by 1
     rake version:write       # Writes out an explicit version.
 
-
 ==  Advanced Developers
 
 * Remember to modify .gitignore to exclude unwanted files.
@@ -463,5 +462,5 @@ which guarantees that all the called programs/tasks will be executed inside the
 
 == Copyright
 
-Copyright (c) 2010 Raoul J.P. Bonnal, Toshiaki Katayama, and Pjotr Prins. See LICENSE.txt for further details.
+Copyright (c) 2010-2012 Raoul J.P. Bonnal, Toshiaki Katayama, and Pjotr Prins. See LICENSE.txt for further details.
 

data/VERSION

@@ -1 +1 @@
-1.2.1
+1.2.2

data/bin/biogem

@@ -16,8 +16,16 @@ if (application_exit[:exit]==0)
   pwd = FileUtils.pwd
   FileUtils.cd "bioruby-#{application_exit[:options][:project_name]}"
   ARGV.clear << "install"
+
   Bundler::CLI.start
   #TODO: call rake directly not from shell
+  # print "Note: if rake gives an error try running biogem from an installed gem\n"
+  print "\trake version:write\n"
   sh "rake version:write"
+  print "\trake gemspec\n"
   sh "rake gemspec"
-end
+  print "Done!\n"
+else
+  $stderr.print "\nERROR: Biogem failed!\n"
+end
+

data/bio-gem.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = "bio-gem"
-  s.version = "1.2.1"
+  s.version = "1.2.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Raoul J.P. Bonnal"]
-  s.date = "2012-01-05"
-  s.description = "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 .\n  The basic idea is to simplify and promote a modular approach to the BioRuby package."
+  s.authors = ["Raoul J.P. Bonnal", "Pjotr Prins"]
+  s.date = "2012-02-16"
+  s.description = "Biogem is a software 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 .\n  The basic idea is to simplify and promote a modular approach to bioinformatics software development"
   s.email = "ilpuccio.febo@gmail.com"
   s.executables = ["biogem"]
   s.extra_rdoc_files = [
@@ -29,22 +29,31 @@ Gem::Specification.new do |s|
     "VERSION",
     "bin/biogem",
     "bio-gem.gemspec",
+    "doc/biogem-hacking.md",
     "lib/bio-gem.rb",
     "lib/bio-gem/application.rb",
+    "lib/bio-gem/generator/render.rb",
+    "lib/bio-gem/mod/biogem-rails.rb",
+    "lib/bio-gem/mod/biogem.rb",
     "lib/bio-gem/mod/jeweler.rb",
     "lib/bio-gem/mod/jeweler/github_mixin.rb",
     "lib/bio-gem/mod/jeweler/options.rb",
-    "lib/bio-gem/templates/bin",
+    "lib/bio-gem/templates/README.rdoc",
+    "lib/bio-gem/templates/bin/bio-plugin",
     "lib/bio-gem/templates/database",
     "lib/bio-gem/templates/db_connection",
     "lib/bio-gem/templates/db_model",
     "lib/bio-gem/templates/engine",
+    "lib/bio-gem/templates/ffi/ext.c",
+    "lib/bio-gem/templates/ffi/ext.h",
     "lib/bio-gem/templates/foos_controller",
     "lib/bio-gem/templates/foos_view_example",
     "lib/bio-gem/templates/foos_view_index",
     "lib/bio-gem/templates/foos_view_new",
     "lib/bio-gem/templates/foos_view_show",
-    "lib/bio-gem/templates/lib",
+    "lib/bio-gem/templates/gitignore",
+    "lib/bio-gem/templates/lib/bioruby-plugin.rb",
+    "lib/bio-gem/templates/lib/plugin.rb",
     "lib/bio-gem/templates/library",
     "lib/bio-gem/templates/migration",
     "lib/bio-gem/templates/rakefile",
@@ -59,38 +68,35 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.required_ruby_version = Gem::Requirement.new("~> 1.9")
   s.rubygems_version = "1.8.10"
-  s.summary = "BioGem helps Bioinformaticians start developing plugins/modules for BioRuby creating a scaffold and a gem package"
+  s.summary = "Biogem is a software generator for Ruby in bioinformatics"
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<bundler>, ["~> 1.0.18"])
-      s.add_runtime_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_runtime_dependency(%q<jeweler>, [">= 1.7.0"])
       s.add_runtime_dependency(%q<rdoc>, [">= 0"])
       s.add_development_dependency(%q<shoulda>, [">= 0"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0.18"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
-      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 1.7.0"])
       s.add_development_dependency(%q<rdoc>, [">= 0"])
     else
       s.add_dependency(%q<bundler>, ["~> 1.0.18"])
-      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<jeweler>, [">= 1.7.0"])
       s.add_dependency(%q<rdoc>, [">= 0"])
       s.add_dependency(%q<shoulda>, [">= 0"])
       s.add_dependency(%q<bundler>, ["~> 1.0.18"])
-      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
-      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 1.7.0"])
       s.add_dependency(%q<rdoc>, [">= 0"])
     end
   else
     s.add_dependency(%q<bundler>, ["~> 1.0.18"])
-    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<jeweler>, [">= 1.7.0"])
     s.add_dependency(%q<rdoc>, [">= 0"])
     s.add_dependency(%q<shoulda>, [">= 0"])
     s.add_dependency(%q<bundler>, ["~> 1.0.18"])
-    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
-    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 1.7.0"])
     s.add_dependency(%q<rdoc>, [">= 0"])
   end
 end

data/doc/biogem-hacking.md

@@ -0,0 +1,396 @@
+# Hacking biogem
+
+Biogem is a Ruby code generator for bioinformatics. It generates a plugin, in
+the form of a gem, which is published automatically on both github and
+rubygems.org.
+
+In this document we discuss ways to modify Biogem, so you can generate your own
+code, and avoid repetitious work. The design of the biogem code generator is based on
+templates, and there are accessible ways to hack it, or even add your own templates.
+
+This document is divided into two sections. In the first section we will create
+a directory, generate a file through a template, and add a test through a
+helper. In the second section we will modify some undesired behaviour in biogem
+through meta-programming.
+
+## Check out the source
+
+
+To change biogem, checkout the source tree to your local machine. E.g.
+
+```sh
+      git clone https://github.com/helios/bioruby-gem.git
+      cd bioruby-gem
+      bundle
+```
+
+Make sure you are running a supported version of Ruby (check the README). 
+Now you can invoke biogem with
+
+```sh
+      bundle exec ./bin/biogem foo
+```
+
+which will create the bioruby-foo plugin for testing. Every time you rerun biogem, make
+sure to remove the bioruby-foo directory first
+
+```sh
+      rm -rf bioruby-foo 
+```
+
+Recommended biogem switches are --with-bin and --rspec
+
+```sh
+      bundle exec ./bin/biogem --with-bin --rspec foo
+```
+
+Note that we are running biogem here within bundler. This may cause a rakefile
+error after generating the plugin (nesting bundler is not a good idea). This can simply be fixed by running the rake by hand in the plugin directory after generation
+
+```sh
+      cd bioruby-foo
+      bundle
+      bundle exec rake version:write
+      bundle exec rake gemspec
+```
+
+Alternatively, install an updated version of biogem, and run biogem without
+bundler with
+
+```sh
+      bundle exec rake install
+      biogem --with-bin --rspec foo
+```
+
+## Invoking the Biogem code generator
+
+In the file ./bin/biogem rake, jeweler and bundler support are loaded and
+Bio::Gem::Generator::Application invoked, which generates the new directory and
+files. After generating code biogem changes directory and runs some rake
+commands in the newly generated plugin.
+
+## Add an CLI option to Biogem
+
+In the first step we want to add a switch to the biogem command line. For our 
+purpose we will add --with-ffi, a switch which will create a template for a foreign
+function interface. Switches are defined in [options.rb](https://github.com/helios/bioruby-gem/blob/master/lib/bio-gem/mod/jeweler/options.rb). We add
+a switch with
+
+```ruby
+          o.on('--with-ffi', 'generate a foreign function interface (FFI)') do
+            self[:biogem_ffi] = true
+          end
+```
+
+This switch will be available as *options[:biogem_ffi]* further on.
+
+## Create a directory
+
+In the method *create_files* in Biogem [jeweler.rb](https://github.com/helios/bioruby-gem/blob/master/lib/bio-gem/mod/jeweler.rb) directories and files get
+created. For example the plugin library file is generated with
+
+```ruby
+        # Fill lib/bio-plugin.rb with some default comments
+        output_template_in_target_generic 'lib', File.join(lib_dir, lib_filename)
+```
+
+which also creates the directory. We explicitly add a directory to store C 
+source files and headers with
+
+```ruby
+        create_ffi_structure if options[:biogem_ffi]
+```
+
+and
+
+```ruby
+        def create_ffi_structure
+          # create ./ext/src and ./ext/include for the .c and .h files
+          mkdir_in_target(ext_dir)
+          mkdir_in_target(File.join(ext_dir,"src"))
+          # create ./lib/ffi for the Ruby ffi
+          mkdir_in_target(File.join(lib_dir,"ffi"))
+        end
+```
+
+## Generate file from template
+
+Templates are stored in lib/bio-gem/templates. We create a template for
+our C extension named [ext.c](https://github.com/helios/bioruby-gem/tree/master/lib/bio-gem/templates/ffi/ext.c), e.g. the C function
+
+```ruby
+        int add_one(int number) {
+          return number + 1;
+        }
+```
+
+which gets copied into the plugins ./ext/src directory with 
+
+```ruby
+        output_template_in_target_generic File.join('ffi','ext.c'), File.join(src_dir, "ext.c" )
+```
+
+Likewise, an include file ext.h gets copied, a Makefile, and the Ruby ffi file, which defines the bindings to ext.c.
+
+(to be continued)
+
+## Modify a generated file with a helper
+
+Similar to Ruby on Rails, we use erb to modify templates based on input parameters.
+Erb is part of the Ruby [standard library](http://ruby-doc.org/stdlib-1.9.3/libdoc/erb/rdoc/ERB.html).
+To use erb we create helper functions. A good example is the main library file that
+gets included by everyone using your plugin using
+
+```ruby
+require 'bio-myawesomeplugin'
+```
+
+The generated file is in your module *lib* directory. The template for that file can be found [here](https://github.com/pjotrp/bioruby-gem/blob/master/lib/bio-gem/templates/lib/bioruby-plugin.rb). 
+Another example generates the
+binary from a [template](https://github.com/pjotrp/bioruby-gem/blob/master/lib/bio-gem/templates/bin/bio-plugin), when generating with the --with-bin switch. It contains the line
+
+```ruby
+        require '<%= project_name %>'
+```  
+
+*project_name* is a helper, a method which is defined in *lib/bio-gem/mod/jeweler.rb* as
+
+```ruby
+    alias original_project_name project_name  
+    def project_name
+      name = original_project_name
+      return 'bio-'+name if name !~ /^bio-/
+      name
+    end
+```
+
+Here, original_project_name is the original method in jeweler. The main thing to note is that you
+can easily create your own helpers - they are available in the erb based templates when they 
+exist in the Jeweler::Generator namespace.
+  
+## Adapt the Rakefile
+
+For our FFI (DRY) the Rakefile needs to be adapted to compile the C file(s) properly. For this
+implementatin I am adding a working example of a C binding, similar to what we do for tests. 
+
+(to be continued)
+
+# Hacking jeweler for Biogem 
+
+The following section discusses surgical changes to biogem.
+
+''Warning, the rest of this document is about Ruby meta-programming. It is not for the faint of 
+heart.''
+
+Biogem builds on [Jeweler](https://github.com/technicalpickles/jeweler).
+
+jeweler comes with a library for managing and releasing RubyGem projects, and
+a scaffold generator for starting new RubyGem projects. Using typical Ruby
+overrides of jeweler methods, also known as meta-programming, Biogem subverts
+Jeweler for our bioinformatics needs (see jeweler::Generator.new example below).
+
+## Invoking the Biogem code generator
+
+In the file ./bin/biogem rake, jeweler and bundler support are loaded and
+Bio::Gem::Generator::Application invoked, which generates the new directory and
+files. Thereafter biogem changes directory and runs some rake commands.
+
+## Inside Bio::Gem::Generator::Application
+
+First Jeweler::Generator.run is run, so the basic scaffolding exists for Rake,
+tests etc. Nothing special so far. Where it gets interesting is that biogem
+overrides Jeweler classes in [./lib/bio-gem/mod/jeweler.rb](https://github.com/helios/bioruby-gem/blob/master/lib/bio-gem/mod/jeweler.rb). In this file, at runtime,
+Jeweler::Generator.new is replaced with our own version, which calls the
+original first, but continues to plug in information. Any time jeweler::Generator.new is called,
+our edition is called. Even from within jeweler!
+
+It is important to check out this file, as many overrides are defined here.
+Also have a look at the *create_files* function. That is where directories and
+files are generated from templates.
+
+## Biogem options
+
+The application generator is programmed from biogem command line options. These
+options are listed in [jeweler/options.rb](https://github.com/helios/bioruby-gem/blob/master/lib/bio-gem/mod/jeweler/options.rb).
+
+## Biogem templates
+
+Biogem templates are listed in [./lib/bio-gem/templates](https://github.com/helios/bioruby-gem/tree/master/lib/bio-gem/templates). These templates use erb to tune content within.
+
+Templates are by in the jeweler.rb override (described above). For example the Rakefile is 
+generated with
+
+```ruby
+        output_template_in_target 'Rakefile'
+```
+
+it is all fairly straightforward. 
+
+## Check out the jeweler source code
+
+From the above you can see how we reprogram jeweler for our needs. To find new
+ways of generating code, we strongly suggest to also check out the [jeweler
+source code](https://github.com/technicalpickles/jeweler/tree/master/lib). The
+jeweler code base is well thought out, and stable.
+
+## Changing jeweler behaviour
+
+Just as an example we are going to override code generated by Jeweler. Jeweler generates
+a dependency for rcov, a Ruby code coverage analyzer. We are going to remove this dependency, 
+without touching the Jeweler code base.
+
+In the Jeweler source code tree rcov is used in two files:
+
+```ruby
+        grep -r rcov *
+        jeweler/generator.rb:      development_dependencies << ["rcov", ">= 0"]
+        jeweler/templates/other_tasks.erb:RSpec::Core::RakeTask.new(:rcov) do |spec|
+        jeweler/templates/other_tasks.erb:  spec.rcov = true
+        jeweler/templates/other_tasks.erb:Micronaut::RakeTask.new(:rcov) do |examples|
+        jeweler/templates/other_tasks.erb:  examples.rcov_opts = '-Ilib -I<%= test_dir %>'
+        jeweler/templates/other_tasks.erb:  examples.rcov = true
+        jeweler/templates/other_tasks.erb:require 'rcov/rcovtask'
+        jeweler/templates/other_tasks.erb:  <%= test_task %>.rcov_opts << '--exclude "gems/*"'
+```
+
+The first step is to remove the rcov entry from development_dependencies. This can be
+done by adding a line in Biogems lib/bio-gem/mod/jeweler.rb. Change it to 
+
+```ruby
+        class Jeweler
+          class Generator 
+            alias original_initialize initialize
+            def initialize(options = {})
+              original_initialize(options)
+              development_dependencies << ["bio", ">= 1.4.2"]
+              development_dependencies.delete_if { |k,v| k == "rcov" }
+              (...) 
+```
+
+You can see here that BioRuby support is always added. The next step is to change 
+the behaviour of jeweler/templates/other_tasks.erb. The code to generate the
+Rakefile lists is 
+
+```ruby
+        <% case testing_framework %>
+        <% when :rspec %>
+          (...)
+        <% when :micronaut %>
+          (...)
+        <% else %>
+        require 'rcov/rcovtask'
+        Rcov::RcovTask.new do |<%= test_task %>|
+          (...)
+        end
+        <% end %>
+```
+
+and, annoyingly, shows that rcov is always added by default (in the final
+'else'). We should communicate with the author of Jeweler to fix this. However, we
+also have the option to override the Rakefile generator. The jeweler Rakefile
+template has the form
+
+```ruby
+        require 'rubygems'
+        <%= render_template 'bundler_setup.erb' %>
+        require 'rake'
+        <%= render_template 'jeweler_tasks.erb' %>
+        <%= render_template 'other_tasks.erb' %>
+```
+
+The two important functions in jeweler.rb are:
+
+```ruby
+    def render_template(source)
+      template_contents = File.read(File.join(template_dir, source))
+      template          = ERB.new(template_contents, nil, '<>')
+      # squish extraneous whitespace from some of the conditionals
+      template.result(binding).gsub(/\n\n\n+/, "\n\n")
+    end
+
+    def output_template_in_target(source, destination = source)
+      final_destination = File.join(target_dir, destination)
+      template_result   = render_template(source)
+      File.open(final_destination, 'w') {|file| file.write(template_result)}
+      $stdout.puts "\tcreate\t#{destination}"
+    end
+```
+
+these find the templates and render them through ERB. 
+
+Naturally, Biogem has needed some overriding behaviour.  In this case Biogems jeweler.rb
+has
+
+```ruby
+    def output_template_in_target_generic_update(source, destination = source, template_dir = template_dir_biogem)
+      final_destination = File.join(target_dir, destination)
+      template_result   = render_template_generic(source, template_dir)
+      File.open(final_destination, 'a') {|file| file.write(template_result)}
+      $stdout.puts "\tcreate\t#{destination}"
+    end    
+```
+
+and, in the case of the --with-db option, the Rakefile already gets modified by Biogem
+
+```ruby
+    output_template_in_target_generic 'rakefile', 'Rakefile', template_dir_biogem
+```
+
+So, what would be the best route here, to change biogem behaviour? We have to rewrite
+the Rakefile template to remove the rcov lines. We can 
+change the *render_template* to allow rewriting the template. Unfortunately there is no
+existing hook for that in jeweler. So, let us inject a hook named *after_render_template*
+to a *render_template* override. First we open the Jeweler::Generator class and move the method to biogem jeweler.rb, renaming the original method to original_render_template:
+
+```ruby
+        class Jeweler
+          class Generator 
+            alias original_render_template render_template
+            def render_template(source)
+              buf = original_render_template(source)
+              # call hook (returns edited buf)
+              after_render_template(source,buf)
+            end
+
+            # new hook for removing stuff
+            def after_render_template(source,buf)
+              if source == 'other_tasks.erb'
+                # remove rcov related lines
+                buf.gsub!(/require 'rcov/rcovtask'/,'')
+                (...)
+              end
+            end
+```
+
+you probably get the gist (the stuff you can do with Ruby meta-programming!).
+The solution chosen overrides original jeweler behaviour without touching
+jeweler itself. Naturally, if it can be handled in jeweler, it is strongly
+preferred.  With our solution a small change in jeweler may now break biogem
+(in software engineering terms: the fix is brittle).
+
+In fact, the jeweler author has responded that the default behaviour for rcov will change now. I.e.
+our fix will go upstream.
+
+Still, for stuff that will not go into jeweler, this is a way of changing
+behaviour.
+
+# DRY (Do not repeat yourself)
+
+This document should help you preventing repeating yourself. Code generation
+can be very useful. When you have something that is useful to yourself, or
+others, and is bioinformatics related, add it to biogem.  When it is more
+generic, add it to jeweler. You may make a lot of people happy.
+
+# More on meta-programming
+
+Thanks to Ruby meta-programming we do not have to change jeweler. With another
+computer language, we would have cloned jeweler and modified the source code
+for our purposes. This would imply a fork of the code base - and the projects
+would have diverged irrevocably. As it stands, we can build on the existing
+jeweler project. Some 'brittleness' may get introduced, as explained above, but in
+general we should normally be able to continue adapting our code base to that
+of jeweler.
+
+The Pragmatic programmers book on [Ruby metaprogramming](http://www.amazon.com/Metaprogramming-Ruby-Program-Like-Pros/dp/1934356476/ref=cm_cr_pr_product_top) is recommended reading.
+
+Copyright (C) 2012 Pjotr Prins <pjotr.prins@thebird.nl>