inochi - Gives life to Ruby projects

Inochi logo



inochi init project=PROJECT [package=PACKAGE] [merger=MERGER]


Runs the given TASK while passing the given RAKE_OPTIONS to rake(1). Otherwise, if TASK is not given, displays a list of available tasks.


-h, --help

Display this manual and exit.

-v, --version

Print version number and exit.


See list of available tasks:


Set up a project named "Foo Bar Baz 123":

inochi init project="Foo Bar Baz 123"

Set up a project that is named "Foo Bar Baz 123" but packaged as "fbb123":

inochi init project="Foo Bar Baz 123" package="fbb123"


Inochi is an infrastructure that gives life to open-source [Ruby] projects and helps you document, test, package, publish, announce, and maintain them.


  • Produces a comprehensive help manual that is written in [eRuby] over [AsciiDoc] and is rendered into a Web page (with RSS feed) as well as a UNIX manual page.

  • Produces beautiful plain-text release announcements that are ready to be published on news outlets such as the [ruby-talk] mailing list.

  • Stores project information in constants in a single Ruby source file.


Project website

Announcements feed

API documentation

Source code (browse online, download, or checkout)

Issue tracker (report bugs, request features, get help)




gem install inochi


gem update inochi


gem uninstall inochi


This tutorial shows how to set up an Inochi project for a "WordCount" tool that counts the number of words in the text given to it.

Creating a new project

Create a directory for the project:

mkdir word_count

Instill Inochi into the directory:

cd word_count
inochi init project="WordCount"

Review pending work marked as "TODO":

grep TODO -nR .

Running the shell command

Run the project’s shell command:

ruby -Ilib bin/word_count

View the project version number:

ruby -Ilib bin/word_count --version

View the project help manual:

ruby -Ilib bin/word_count --help

Building the help manual

Build the help manual:

inochi man

View the help manual in a terminal:

man -l man/man1/word_count.1

View the help manual in a Web browser:

firefox man.html

Implementing the library

Append the following code to the test/word_count_test.rb file:

class TestWordCount < Test::Unit::TestCase
  def test_handles_empty_input
    assert_equal(0, WordCount.count(nil))
    assert_equal(0, WordCount.count(''))
    assert_equal(0, WordCount.count(' '))

  def test_handles_single_words
    assert_equal(1, WordCount.count('a'))
    assert_equal(1, WordCount.count('foo'))
    assert_equal(1, WordCount.count('bar'))

  def test_handles_multiple_words
    assert_equal(2, WordCount.count('a b'))
    assert_equal(2, WordCount.count('a-b'))
    assert_equal(2, WordCount.count('a/b'))

  def test_ignores_punctuation_and_space
    assert_equal(0, WordCount.count('!'))
    assert_equal(0, WordCount.count('! @ # % #!@#'))
    assert_equal(0, WordCount.count(' !'))
    assert_equal(0, WordCount.count('! '))
    assert_equal(0, WordCount.count(' ! '))
    assert_equal(0, WordCount.count('   !   '))

Run the test suite and observe that all tests fail:

ruby test/runner

Append the following code to the lib/word_count.rb file:

module WordCount
  # Returns the number of words in the given input.
  def WordCount.count input

Run the test suite again and observe that all tests pass:

ruby test/runner

Implementing the shell command

Append the following code to the bin/word_count file:

input =
total = WordCount.count(input)
puts "There are #{total} words in the input."

Run the project’s shell command on the README file:

ruby -Ilib bin/word_count README


Inochi provides the following tasks. Some of these are explained below.


Build all release announcements.


Build RSS feed announcement.


Build HTML announcement.


Build plain text announcement.


Build API documentation.


Remove any temporary products.


Remove any generated file.


Build release package for RubyGems.


Build RubyGems package specification.


Instill Inochi into current directory.


Build the help manual.


Publish a release of this project.


Publish gem release package to


Publish help manual, API docs, and RSS feed to project website.

inochi init

Installs the Inochi infrastructure for the project in the current working directory or upgrades a previous installation thereof.


inochi init project=PROJECT [package=PACKAGE] [merger=MERGER]



Name of the project. This will be normalized into the name of a Ruby module that will serve as a namespace for all code in the project.


Name of the project’s package directory, shell command, and basename of the project library file.


Command that invokes a text merging tool with three arguments: (1) old file, (2) new file, (3) output file. The command should direct the result of merging the old file and the new file to the output file. In addition, the command must not modify the old file or the new file.


Pre-existing files are not overwritten. Instead, it is your responsibility to merge changes between pre-existing and newly generated files. You can do this with the aid of an automated text merging tool such as [meld], [tkdiff], or [kdiff3] by following these steps:

  1. Create a file named merge2 containing the following text:

    old=$1; new=$2; out=$3;
    # meld "$new" "$out"                            # use meld
    # tkdiff "$old" "$new" -o "$out"                # use tkdiff
    # kdiff3 --merge "$old" "$new" --output "$out"  # use kdiff3
    # diffuse "$old" "$out" "$new"                  # use diffuse
  2. Uncomment the line corresponding to the tool you wish to use.

  3. Make the file executable:

    chmod +x merge2
  4. Pass the file’s path as the value of MERGER:

    inochi init merger=path/to/merge2

Now your chosen text merging tool will be launched to help you transfer your changes. When you are finished, save the merged file and exit the merging tool. If you do not want to transfer any changes, then simply exit the merging tool without saving any changes to the merged file!

inochi api

Builds API documentation for the project’s Ruby library using [YARD]. Ruby constructs marked with @private are omitted from the API documentation.

inochi man

Renders the help manual’s source files into:


Input for [AsciiDoc], rendered by [Ember].


HTML web page, rendered by [AsciiDoc].


UNIX manual page, rendered by [AsciiDoc].

inochi gem

Builds a gem, which is a release package in [RubyGems] format:


The gem itself.


Ruby representation of the gem’s specification.

The gem specification is pre-initialized with information from the project’s Ruby library and help manual. In particular:


Plain text version of all content between the "ABOUT" heading and any subsequent heading.


Plain text version of all content between the "AUTHORS" heading and any subsequent heading.


Only contains the project’s LICENSE and CREDITS files, rendered help manual, Ruby library, shell command, and C extension.

All other files (such as the test suite and help manual source files) are omitted (1) to reduce the gem file size and (2) because they are really only needed during development.

The gem specification can be further customized through the :gem_spec_logic parameter defined in the project’s configuration file.

inochi ann

Builds release announcements which can be edited by hand before publishing:


Web page version of the release announcement.


Plain text version of the release announcement; converted from the Web page version by [Lynx].


RSS feed version of the release announcement.

inochi pub:web

Publishes the help manual, API documentation, and RSS feed to project website using rsync(1) according to the :pub_web_* parameters defined in the project’s configuration file.


A project instilled with Inochi is composed of a configuration file, a license, source code, documentation, and a Web presence; which are all explained below.

Configuration file

A project’s configuration file is a [YAML] document named inochi.conf that defines the following optional parameters used by some Inochi tasks:


Attributes to pass to AsciiDoc when rendering the HTML manual page. See "Backend Attributes" in the AsciiDoc manual for a list of all attributes.


Location where the inochi pub:web command will upload files. This value can use any local/remote/protocol syntax supported by rsync(1).


Options for rsync(1), which uploads files for the inochi pub:web command.


Additional files for the inochi pub:web command to upload. The values listed here can use any local/remote/protocol syntax supported by rsync(1).


  - some/file
  - some_user@some_host:some/path

Ruby code that will configure this project’s RubyGem before it is built by the inochi gem command. This code has access to a local variable named gem which holds a Gem::Specification object representing this project.


:gem_spec_logic: |
  # show the Inochi-provided specification for this project's gem
  puts gem.to_ruby

  # add files that are outside this project directory to the gem
  gem.files += ['some', 'files', 'in', 'this', 'directory']

  # omit some added files in this project's directory from the gem
  gem.files -= ['lib/top_secret.rb', 'bin/more_top_secret_stuff']

  # and so on...  anything is possible!  use your imagination!

License file

A project’s license defines the legal conditions under which the project is developed and distributed. It is stored in a file named LICENSE at the root of the project directory.

Ruby library

A project’s Ruby library is composed of the following files:


Defines the project’s namespace (Ruby module or class) and registers sub-libraries to be automatically loaded on demand (Kernel#autoload).


Defines project information in Ruby constants within the project’s namespace (Ruby module or class) and establishes version constraints for gems this project depends on if RubyGems is available in the user’s environment. Unsatisfied constraints are simply printed to the standard error stream; they do not raise a Gem::LoadError exception.

Test suite

A project’s test suite is composed of the following files:


Executable Ruby script that hides the details of running the test suite.


Ruby source file that prepares the testing environment by loading a testing library and defining common knowledge and utility logic shared by the actual tests.


Ruby source files that perform the actual testing.

Shell command

A project’s shell command is an executable Ruby source file in the bin/ directory named PACKAGE. It expects that the project’s lib/ directory is already present in Ruby’s $LOAD_PATH (see [HACKING] below). Thankfully, this expectation is automatically met when the project is installed via RubyGems.

Help manual

A project’s help manual is a monolithic [eRuby] template that is (1) processed by [Ember] with its shorthand notation, hierarchical unindentation, and missing <% end %> inference features enabled, and (2) composed of the following source files:


Primary source file of the help manual that (1) defines common knowledge and utility logic and (2) divides its content into the following files for easier editing and maintenance.


Describes how the project’s shell command can be invoked.


Introduces the project and its Web presence.


Instructions on installing, upgrading, and removing the project.


Explains how to use the project in detail.


Instructs fellow software developers on running, testing, and hacking the project’s source code.


Records notes about current and past releases of the project in terms of incompatible changes, new features, bug fixes, and housekeeping activities.


Attributes all developers and contributors whose efforts have made the project what it is today.


Refers to related commands, help manuals, and topics beyond this project.

Web presence

A project’s a Web presence is composed, at minimum, of the following:

Project website

Where the help manual, API documentation, and RSS feed can be accessed (hopefully) permanently.

Code repository

Where fellow software developers can obtain the latest source code.

Issue tracker

Where users can contribute patches, request features, and get help.

You may choose to omit some or all of these components by simply not mentioning them in the "Resources" section of the help manual’s README source file.



Install Ruby libraries necessary for development using [Bundler]:

bundle install


[Inochi] serves as the project infrastructure for Inochi. It handles tasks such as building this help manual and API documentation, and packaging, announcing, and publishing new releases. See its help manual and list of tasks to get started:

bundle exec inochi --help     # display help manual
bundle exec inochi --tasks    # list available tasks

$LOAD_PATH setup

Ensure that the lib/ directory is listed in Ruby’s $LOAD_PATH before you use any libraries therein or run any executables in the bin/ directory.

This can be achieved by passing an option to Ruby:

bundle exec ruby -Ilib bin/inochi
bundle exec irb -Ilib -r inochi

Or by setting the $RUBYLIB environment variable:

env RUBYLIB=lib bundle exec ruby bin/inochi
env RUBYLIB=lib bundle exec irb -r inochi

Running tests

Simply execute the included test runner, which sets up Ruby’s $LOAD_PATH for testing, loads the included test/test_helper.rb file, and then evaluates all test/**/*_test.rb files:

ruby test/runner

Its exit status will indicate whether all tests have passed. It may also print additional pass/fail information depending on the testing library used in the test/test_helper.rb file.


Fork this project on GitHub and send a pull request.


Version 6.1.0 (2011-06-29)

Prerequisite changes
  • AsciiDoc 8.6.5 is now required.

New features
  • Use AsciiDoc’s HTML5 backend to build HTML manual.

  • Use sans headings and serif content in print style.

  • Show target URL beside external hyperlinks in print style.

  • Show cross-reference hyperlinks as normal text in print style.

Bug fixes
  • Admonition icons were not emitted in HTML manual.

  • Require Rake 0.8.x because 0.9 is incompatible.

  • Fix undefined method ‘write’ for #<Syck::Emitter.

  • Use bundle exec to run Ruby and IRB in HACKING.


Version 6.0.2 (2011-04-21)

This release adopts some common Rails testing and development conventions, drops runtime gem version dependency establishment in favor of [Bundler], produces a gemspec file for greater interoperability, and improves merging.

Incompatible changes
  • Remove pub:ann tasks; users can manually announce where/if they want to.

  • Remove runtime gem version dependency establishment from lib/*/inochi.rb.

  • Replace DEVTIME constant in lib/*/inochi.rb with [Bundler]'s Gemfile.

  • Rename RUNTIME constant to GEMDEPS in lib/*/inochi.rb.

  • Rename test/helper.rb to test/test_helper.rb per Rails convention.

New features
  • Add gem:spec task to generate a gemspec file for your project.

  • Allow gem package to be built via gem build *.gemspec as Yehuda Katz suggests.

Bug fixes
  • Make old and new files read-only before merging.

  • Omit CREDITS file from gem because help manual contains it.

  • Add diffuse tool to the example merge2 script in help manual.

  • Reduce font size to accomodate small screens in help manual.

  • Revise project & manual version mismatch error.

  • Revise project introduction in help manual.

Version 5.1.0 (2010-08-14)

This release uses [Pygments] for syntax highlighting, adds icons to admonitions, speeds up the pub:web task, and further refines the HTML version of your project’s help manual.

New features
  • Use admonition icons that are installed with AsciiDoc.

  • Use Pygments for syntax coloring in AsciiDoc 8.5.4.

Bug fixes
  • Only build what will be uploaded in pub:web task.

  • Do not display table of contents in print preview mode.

  • Increase body max-width to 50em to show 80 characters.

  • Update DOM selectors for AsciiDoc 8.5.4 in ann tasks.

  • Get straight to the point when stating project purpose.

Version 5.0.2 (2010-08-10)

This release emits hyperlink URLs in the generated UNIX manpage, beautifies the plain-text release announcement, and fixes incorrect AsciiDoc usage.

Bug fixes
  • Emit hyperlink URLs when rendering the help manual into UNIX manpage format by using xsltproc(1) instead of a2x(1). Thanks to Rainer Müller on the [AsciiDoc] mailing list for helping me find the solution to this problem.

  • Do not add space before paragraph titles in plain-text announcement.

  • Use proper AsciiDoc bibliography syntax in the BEYOND file.

  • Only list related UNIX manpages in the "SEE ALSO" section.

Version 5.0.1 (2010-08-09)

This release restores missing metadata in generated gem packages.

Bug fixes
  • Project description and author names were not parsed correctly from the help manual when building gem packages.

  • Redistribute load-order indices in internal Rake task filenames.

Version 5.0.0 (2010-08-07)

This release switches from [Ronn] to [AsciiDoc] for writing the help manual, reduces the file size of generated gem packages, and fixes some bugs.

Incompatible changes
  • Rename the inochi.opts file to inochi.conf

  • Use [AsciiDoc] instead of [Ronn] to render the help manual.

    • Move "SETUP" and "SYNOPSIS" sections into their own files.

    • Rename SETUP file to INSTALL per Linux convention.

    • Add :man_asciidoc_attributes option to inochi.conf

  • Do not include HTML manual in gem package. This reduces the gem file size and makes the project website the only official place to obtain the HTML manual.

Bug fixes
  • Add workaround for lynx -dump ignoring <base href="…"/>

  • Always load project info before non-init tasks.

  • Another Ruby 1.9.2-rc2 fix for Nokogiri usage.


  • Use single quotes for string values in inochi.rb template.

  • fetch_nodes_between(): report errors and refactor.

Version 4.0.1 (2010-07-28)

This release fixes a bug in gem version dependency establishment.

Bug fixes
  • Gem version dependencies were not being established in Ruby 1.8.7 and 1.9.2 because Kernel#gem is a private method in those Ruby versions.

    To propagate this fix into your projects, please reinitialize them with this version of Inochi.

Version 4.0.0 (2010-07-25)

Incompatible changes
  • Rename the "VERSIONS" section in the HISTORY file to "HISTORY".

Changes you will see in upgraded or newly generated projects
  • Rename the FURTHER file to BEYOND.

  • Rename test/test_helper.rb to just test/helper.rb.

  • Store resource URLs in variables in MANUAL file for reuse.

  • Provide more precise link to ruby-wrapper tool in HACKING file.

New features
  • Ensure that project version matches release notes before building a gem. This helps to prevent the problem where you sometimes forget to update both the release notes and the project information file simultaneously.

  • Display announcement message to user (and make them confirm it) before publishing to ruby-talk. This helps to prevent you from appearing inept and having to apologize later for your publishing blunders.

  • Add -d (to enable $DEBUG) and -v (to enable $VERBOSE) command-line options to the generated test/runner script.

Bug fixes
  • Various compatibility fixes for Ruby 1.9.2-rc2.

  • Prefix test/runner command with "ruby" for Windows users.

  • Ember::WEBSITE was always being emitted in README file.

  • Add version constraints for YARD and Mechanize dependencies.

  • Upgrade from Dfect 1.1.0 to Detest 3.1.0 for unit testing.

  • Upgrade to Ronn 0.7.0 for generating this user manual.

Version 3.0.0 (2010-04-27)

Incompatible changes
  • The require() class method is no longer emitted on your project’s namespace. Instead, gem version constraints are established up front when your project’s Ruby library is first loaded.

  • Author names are now fetched from the "AUTHORS" section, not "CREDITS".

  • Project information is now placed in the "NAME" section, not "ABOUT".

Bug fixes
  • Reflect current Inochi version in gem constraint.

  • Forgot to list [Ember] as a runtime gem dependency.

  • Move all task documentation into new "TASKS" section.

  • Move TASKS & PROJECTS information into separate files.

Version 2.0.1 (2010-04-25)

This release fixes some bugs and adds a simple tutorial to the help manual.

Bug fixes
  • Task files were not loaded in correct order. As a result, certain Inochi tasks would fail (depending on the sorting order of your filesystem) with the following cryptic error:

    inochi aborted!
    Don't know how to build task ''
    /usr/lib/ruby/gems/1.9.1/gems/rake-0.8.7/lib/rake.rb:1728:in `[]'
    (See full trace by running task with --trace)
  • LICENSE file template lacked a "TODO" marker.

  • Forgot version number heading in announcement.

  • Restored the simple WordCount tutorial from version 1.1.1.

Version 2.0.0 (2010-04-24)

This release makes Inochi a development-time dependency only, documents nearly everything in the help manual, renders the help manual as a UNIX manual page, simplifies the project infrastructure it provides, and removes needless cruft.

Incompatible changes
  • Inochi is no longer a runtime dependency (gem or otherwise) for projects that use it. It also no longer runs tests, creates project namespaces, or provides libraries for internationalization, combinatorics, command-line parsing, utility logic, or Rakefiles.

    See [PROJECTS] to learn about the new Inochi infrastructure.

  • The help manual is now processed by [Ronn] instead of [ERBook]. As a result, you may only use plain [Markdown] and [eRuby] when writing it.

  • Announcement publishing tasks no longer read login information from the ~/.config/inochi/logins.yaml file and prompt you to enter that information manually instead. As a result, the forementioned file is no longer recognized or used by Inochi so you may safely delete it.

New features
  • The help manual is now available as a UNIX manual page (thanks to [Ronn]) and is now divided into smaller files that can be read directly without needing a special viewer, and are named according to open-source packaging conventions (such as README, HACKING, and LICENSE) so that they draw the attention of users unaccustomed to the organization of your project.

  • A require class method is now added to the project’s namespace. This method verifies that the library or gem being required meets the dependency version constraints defined by the project.

  • A test/runner script is now generated. It provides a fast, self-contained way to run your project’s test suite.

  • Inochi is now a Rake application. A Rakefile is not necessary.

  • Many KISS and YAGNI fueled iterations later, this is it! :-)

  • Nearly every aspect of Inochi is now meticulously documented in the help manual to the best of my ability. If I missed something important, please notify me or contribute the correction yourself!

Version 1.1.1 (2009-10-03)

This release improves Ruby 1.9 support and upgrades gem dependencies.

Bug fixes
  • require() was unable to find project library in Ruby 1.9.2dev.

  • Ruby 1.9 warning about "shadowing outer variable".

  • Ruby 1.9 error about "incompatible encoding regexp match".

  • The "spicycode-rcov" project was officially renamed to "relevance-rcov".

  • Upgrade to RubyForge 2.x library for publishing gems.

Version 1.1.0 (2009-09-06)

This release improves the user manual and scaffold generator output, injects more metadata into gems, adds support for Microsoft web browsers, and fixes some bugs.

New features
  • Add instructions for building gems without Inochi as a runtime dependency.

  • Put release notes in "description" field of gemspec, as suggested by Eric Hodel, so that subscribers of the RubyForge gems feed are aware of the changes in a published gem.

  • Set the "date" field in gemspec to project release date.

  • Change file extension of generated user manuals from .xhtml to .html to accomodate Microsoft web browsers' inability to process the application/xhtml+xml mime type.

Bug fixes
  • The sdoc library was necessary to run rake test.

  • Forgot to add :develop option to scaffold generator output.

  • Make "rake lang:dump" unconditionally overwrite the dump file.

  • Fix gem not being built and prevent Maruku errors for the dummy "WordCount" project in the user manual.

  • Use /usr/bin/env instead of /usr/bin/ruby to launch Ruby for better portability.

  • Use simpler Copyright reminder at the top of every file.

  • Open source is for fun, so speak of "related works", not "competitors".

  • Rename "Tutorial" to "General walkthrough" in user manual and add a "Specific topics" section for housing uncommon use cases.

  • Remove "logistics" section and redistribute its contents in more suitable locations in the user manual.

Version 1.0.0 (2009-05-03)

This release allows your gems to not depend on Inochi, lets you choose which unit testing library to use, adds new utility libraries and rake tasks, and fixes some bugs.

Incompatible changes
  • Your program is no longer halted by Inochi.init() and Inochi.rake() if gem dependencies are not satified. A warning is issued instead.

  • The project_summary and project_history nodes, which are provided by to the user manual, have been renamed to project and history respectively.

  • ERBook 7.1.0 is now used for generating the user manual. This is a major step up from the previous version, and so it has incompatible changes. See its release notes for details.

  • SDoc is now used to generate API documentation instead of YARD. If you link to particular classes or methods in the generated API documentation, be sure to update your link addresses!

  • Minitest is no longer the default testing library. You must specify which testing library you want to use via the :test_with option of the Inochi.rake() method. See the "Test execution" section for details.

  • The "pak" rake task, which is provided by Inochi.rake(), has been renamed to "gem".

New features
  • Add :inochi_consumer and :inochi_producer options to Inochi.rake() which allows you to avoid having Inochi as a runtime and development dependency, respectively, for your project’s gem.

    This is useful if you just want to use Inochi facilities for building a gem for a pure Ruby library that does not have any need for Inochi’s runtime convenience facilities.

  • Add :develop option for Inochi.init() which lets you specify RubyGems as development dependencies in the same way as the :require option.

  • Add "lint" rake task which reports code quality statistics.

  • Add "test:cov" rake task which reports code coverage statistics.

  • Add "test:ruby" task which runs all tests with multiruby.

  • Add rake opts= environment variable, which lets you specify command-line arguments directly to the Ruby interpreter, for all test* rake tasks.

  • Add inochi/util/combo combinatorics library for enumerations, permutations, and combinations which are all useful in exhaustive brute-force unit testing.

  • Add inochi/util/tempdir library which really should be in the Ruby standard library.

Bug fixes
  • The "enable email notification" checkbox was not activated properly when posting announcement to ruby-talk mailing list via Ruby-Forum.

  • Mark gems needed by Inochi.rake() as development dependencies.

    Users must now run gem install Inochi --development to install these dependencies. This also solves the recursive dependency problem between Inochi and ERBook.

  • Set executable in gem specification only if it exists.

  • Fix parsing of stack trace in Ruby 1.9.

  • Write contributor names in CREDITS file instead of in the user manual.

  • Use completely lowercase name for Rakefile.

  • Add copyright statement at the top of every source file.

Version 0.3.0 (2009-02-12)

This release adds support for language translations, improves the user interface, and fixes a show-stopper bug for Windows users.

New features
  • Add support for language translations of phrases used in a project.

  • Add "lang:dump" Rake task for extracting language phrases from project.

  • Add "lang:conv" Rake task for translating dumped phrases into various languages using the BabelFish translation service.

  • Add --locale option to a project’s main executable for setting user’s preferred language in spite of the user’s locale environment.

  • Notify user when attempting to publish announcements in the "pub" Rake tasks.

Bug fixes
  • In Windows, ENV['USERPROFILE'] gives the path to the user’s home directory and ENV['HOME'] is not defined.

  • The only real solution to the circular gem dependency problem is:

    gem install --force

    You should update the "Setup" section in your projects' user manuals accordingly.

  • Break the huge lib/inochi/inochi.rb library into smaller files.

  • Instead of adding methods to singleton classes directly, define modules and extend to them so that YARDoc documents the methods appropriately.

  • List all project contributors globally in the "Credits" section.

  • Remove "Contributor kudos" paragraph in release notes in favor of crediting contributors inline with each item in the release notes.

  • Mention that the project license is ISC for the reader’s convenience.

Version 0.2.0 (2009-01-25)

This release adds support for unit testing, improves the portability of Inochi and configurability of your projects, adds new content to the user manual, and fixes some bugs.

New features
  • Added support for unit testing via the minitest library.

  • The scaffold generator now emits a default unit test for the main project library.

  • Added optional ProgramName parameter to the scaffold generator. This allows you to specify reasonable program names when your project module has a strange capitalization:

    $ inochi ERBook
    create er_book/LICENSE
    $ inochi ERBook erbook
    create erbook/LICENSE
    $ inochi ERBook foobar
    create foobar/LICENSE
  • Allow project authors to be specified via Inochi.init :YourProject, :authors => [['name', 'mail']] (thanks to Florian Gilcher)

Bug fixes
  • Run on both JRuby and normal Ruby in multiple versions and with different executable names on Windows. (thanks to Florian Gilcher)

  • Use Gem::RubyGemsVersion instead of a shell command to determine rubygems version for generation of setup.erb. (thanks to Florian Gilcher)

  • Add blank lines between all list items, not just multi-line ones, in the plain-text version of the release announcement for improved readability.

  • Omit LaTeX-style heading numbers from release announcements. They caused confusion, especially in plain-text announcements, when trying to determine which version of a project was released.

  • Added unit tests for utility methods provided by the Inochi module: project name calculation and CamelCase to snake_case conversion.

Version 0.1.0 (2009-01-13)

This release reattempts to fix the circular dependency problem that occurred when installing either Inochi or ERBook.

New features
  • Inochi.init() now adds #major(), #series(), and #requirement() instance methods to a project’s VERSION constant.

Bug fixes
  • Solved circular dependency problem by making inochi gem not dependent on erbook gem. However, ERBook is still required during runtime and is supplied on the gem install command for Inochi.

    The "Installing" section has been updated accordingly.

  • Add forgotten Rake dependency for Inochi gem.

Version 0.0.1 (2009-01-13)

This release fixes some show-stopper bugs.

Bug fixes
  • The name of the project library was being determined incorrectly. (thanks to Florian Gilcher)

  • There was a circular dependency problem when installing the Inochi gem. (thanks to Florian Gilcher)

    The solution is to specify the --force option when installing the gem. The "Installing" section has been updated accordingly.

  • Generated project scaffolds now check against the major version of the yInochi` gem, to avoid runtime version conflicts.

  • Only add project libraries to $LOAD_PATH if not already there.

Version 0.0.0 (2009-01-13)

This is the first release of Inochi. Enjoy!


Suraj N. Kurapati


Florian Gilcher, Peileppe Production, Rainer Müller

The "inochi.png" image and its "inochi.svg" source utilize the "3 flowers" graphic[1], which was created and released into the public domain by Peileppe Production[2] on June 25, 2008.


(the ISC license)

Copyright 2008 Suraj N. Kurapati <>

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.