physique 0.3.4 → 0.3.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NWU4MGE4OWY1OGU2ODQyZTZlYmQ1ZjJlNzU0MzU2YTY5ZjllZGViMg==
+    MzY3MGZmNzZjZjU2YmVlZTdiMDAxYzZhYzZiZDc5ZTY5NDFjZjNiMw==
   data.tar.gz: !binary |-
-    NzE1ZjQ5MmU1MjdhZmMxMDM4ODM1MWUxOWNmZDE5YzA3NWM2MzkzMw==
+    N2M3MjUyMDE4ZjMxM2JkZDNjYTZkMjM2Y2M3MzZhYWVhOTcyNjhmOA==
 SHA512:
   metadata.gz: !binary |-
-    MDZkMWQxZTMzNGFlNjQzODgyNzI0MmI4YWU5MjVkMzQ0NmU2NTc5ZTg1MDAz
-    NDIzZDVlNjhlZTZmOGE5YTYxNWRkMzk1YmM2ZTk5YjMxMTEzZjM1Mzk0NDg1
-    MTIyMjQ3ZjUxNDRiZmZjNDVlYjY5Y2Y2YjQwZTU4ZDJlYzQ1YjM=
+    N2I3Y2U3YjFiMDYwMWMxNzk1NjM4ZjEwMmFhNmUwNGYxZWU1ZmE1MDIwNTQz
+    YTEwYzI2Y2NhZjQwYmFiMzg3ZTFkYzM0ZWM0MGUwMzYxZTMwOTEyYTE2M2Jj
+    OTAwMDdkN2I1MGEzYjE4NmIxYjA2Zjk4ZTNlZTBhNjY1ZTk5OGE=
   data.tar.gz: !binary |-
-    MzJiYTg2NzhhZGQxNWMyMDdiMjM3YTQ5YWZiNTFlYjcwNDRjZDMzMWJjNzQx
-    YzkxNTEwYjY0NWU4MjQxMjJkYWEzMWJjY2I4ZTAxMTExM2UyMDUwNzRmNDY3
-    OWNlZDVlNTMxYTc2NjYwYjkzYjY2MTA4NmY2NmVjZTYzZjU4N2M=
+    Y2RlMDE5ZTUxMjQ4NDEzZTZlYTRlYTQyYTEyZjczMzVjNmE1YmY5YjUxYTVh
+    NDA1NDYyYTNlNTRkNTBkNGQ1ZTNlYTE4ZjBmMzRiM2JkZDhhMzA3MGNjZWEw
+    YTljN2E1MTVmMzliMjIxNmYzMGM5M2ViYjMzMDhlYjdkNGE4YTc=

data/FLUENT_MIGRATOR.md

@@ -0,0 +1,301 @@
+# Using Physique with Fluent Migrator
+
+Physique paired with FluentMigrator creates a great developer workflow for managing databases as part of your build.
+
+## Prerequisites
+
+For the purposes of this guide we are making the following assumptions:
+
+* You have already configured your solution to use Physique.
+
+* You are using a SQL Server database.
+
+  NOTE: Physique currently only works with SQL Server. Support for other databases is certainly possible, but not yet implemented.
+
+* You have SQL Client Tools installed and available on your `PATH`.
+
+  Physique uses `SQLCMD.exe` to execute scripts on the command line.
+
+## Creating a FluentMigrator Project
+
+Create a new database project and add the following files and folders:
+
+    ├─ MyProject.Database
+    │  ├─ _Scripts
+    │  │   ├─ create.sql
+    │  │   ├─ drop.sql
+    │  │   └─ seed.sql
+    │  └─ Migrations
+    └─ MyProject.Database.csproj
+
+In the `create.sql` script add the following:
+
+```sql
+-- Create the database
+CREATE DATABASE $(DATABASE_NAME)
+GO
+```
+
+In the `drop.sql` script add the following:
+
+```sql
+-- Drop the database
+if EXISTS(select name from master.dbo.sysdatabases where name = '$(DATABASE_NAME)') begin
+    drop database $(DATABASE_NAME)
+end
+GO
+```
+
+As you can see we are not specifying the database name in the scripts.  Instead, we are using a variable that will be substituted by Physique when we run our tasks.
+
+## Configuring your Rakefile to use FluentMigrator
+
+Open your Rakefile and add the following to your solution's config:
+
+```ruby
+Physique::Solution.new do |s|
+  #...
+  s.fluently_migrate do |db|
+    db.instance = ENV['DATABASE_SERVER'] || '(local)'
+    db.name = ENV['DATABASE_NAME'] || 'MyDatabase'
+    db.project = 'src/MyProject.Database/MyProject.Database.csproj'
+    db.scripts_dir = '_Scripts'
+  end
+end
+```
+
+Here we are telling Physique:
+
+* We will be managing a database named 'MyDatabase' on the '(local)' instance.
+
+  These settings can be overridden when the DATABASE_NAME and DATABASE_INSTANCE variables are present.  This is particularly useful when incorporating Physique into your continuous integration or automated deployment process.
+
+* The path to the project file where are migrations will be implemented.
+
+* The folder within the migrations project that contains our workflow scripts.
+
+## FluentMigrator Tasks
+
+Now we can run `bundle exec rake -T` to examine the tasks Physique has created for us.  It should look something like this:
+
+```
+rake compile                             # Builds the solution
+rake compile:build                       # Builds the solution using the Bu...
+rake compile:clean                       # Builds the solution using the Cl...
+rake compile:rebuild                     # Builds the solution using the Re...
+rake db:create                           # Create the database
+rake db:drop                             # Drop the database
+rake db:migrate                          # Migrate database to the latest v...
+rake db:new_migration[name,description]  # Create a new migration file with...
+rake db:rebuild                          # Drop and recreate the database
+rake db:rollback                         # Rollback the database to the pre...
+rake db:seed                             # Seed the database with test data
+rake db:setup                            # Create the database and run all ...
+rake db:try                              # Migrate and then immediately rol...
+rake restore                             # Restores all nugets as per the p...
+rake test                                # Run unit tests
+```
+
+Look at all of our shiny database tasks!
+
+In case it wasn't obvious, all of the FluentMigrator tasks are prefixed with `db`. Here's a break down of each task does.
+
+### Basic Tasks
+
+* `db:create` - Creates the database.
+* `db:drop` - Drops the database.
+* `db:seed` - Seeds the database with test data.
+
+As you might have guessed, these three tasks simply execute the SQL scripts in your project's `_Scripts` folder.  You probably won't call these directly too often but they are required by the other tasks.
+
+If you don't create these files in your project, FluentMigrator will provide a default implementation for you.  However, it's recommended that you create the scripts so that you have fine grained control over these steps.
+
+#### A Note About Seed Data
+
+The seed script is the place for you to place all of the test data you will need for local development.  It's also a great way to provide a consistent set of test data that can be used during integration testing.
+
+### Migration Tasks
+
+* `db:migrate` - Builds the migrations DLL and migrates the database to the latest version.
+* `db:rollback` - Builds the migrations DLL and rolls back the most recent migration.
+* `db:try` - A `db:migrate` followed by a `db:rollback`.  With this task, you can test a migration that you are working on, then roll it back so that you can continue to add to it.
+
+One of the more annoying things I run into when developing migrations is forgetting to build my migrations project before attempting to migrate the database.  Physique will make sure the migrations assembly is built before running it.
+
+### Build Tasks
+
+* `db:setup` - This task creates the DB, migrates it to the latest version, and executes the seed script to populate it with test data.
+* `db:rebuild` - Drops the database, then executes a `db:setup`.  This task is useful in your Continuous Integration process for testing the integrity of your migrations.
+
+### New Migration Task
+
+* `db:new_migration[name,description]` - Creates a new migration class and adds it to the migrations project. We'll talk more about this in the following section.
+
+## Developer Workflow
+
+### Starting Fresh
+
+Let's say I'm a new developer and it's my first day on the job working on an existing project.  The team I joined (in their infinite wisdom) is using Physique to manage their build process.  The first thing I want to do is checkout the source, build it, build all of the databases locally and then run all of the unit tests to make sure my local copy is configured correctly.
+
+Assuming I have ruby installed on my machine, all I need to do is run the following:
+
+```
+$ git checkout repo-url
+$ bundle install
+$ bundle exec rake test
+```
+
+Thats it!
+
+"But I didn't run any of the database tasks," you might be asking.  That's true.  And therein lies the power behind Physique's build phases.  When you configure a migrations project in Physique, the `db:rebuild` step is automatically registered as a dependency of the `test` phase of the build.  So when you run your tests, all of your databases are built too.
+
+There will be times when you will want to delete and rebuild your local databases: for example, if there were data model changes since your last pull, or if you were experimenting with some db changes on one branch, and need to switch to a different branch to work on something new.
+
+To rebuild the databases:
+
+```
+bundle exec rake db:rebuild
+```
+
+### Creating a New Migration
+
+To create a new migration inside your project, run the following:
+
+```
+rake db:new_migration[migration_name,"migration description"]
+```
+
+This will create a new FluentMigrator class and add it to the migrations project.  It will automatically add a timestamp to the filename and `MigrationAttribute` to ensure that your migrations are run in sequential order and don’t conflict with anyone else on your team.
+
+NOTE: Because this task actually edits the project file, you should make sure that all of your changes are saved to disk before running it.
+
+As you can see this task takes a few parameters.
+
+* `migration_name` - This is the name of the Migration class you want to create.
+* `migration_description` - (Optional) A description that will be stored in the VersionInfo table after the migration is applied.
+
+As a hypothetical example, let’s say we wanted to create a new migration to add a new status column to our Order table.  The command might look something like this.
+
+```
+rake db:new_migration[AddStatusToOrder, "Add a new status column to the order table"]
+```
+
+After running this task, the IDE will alert you that the project file has been modified.  Select Reload and you should see the new migration in the Migrations folder.  At this point, all that’s left to do is add your migration code to the `Up` method.
+
+### Running Your Migrations
+
+After creating a new migration, you will want to apply it to your local database.  Unsurprisingly, this is done by running:
+
+```
+bundle exec rake db:migrate
+```
+
+This will execute any migrations that have not yet been applied.
+
+If you want to rollback the last migration applied, the following command will do the trick.
+
+```
+bundle exec rake db:rollback
+```
+
+It’s common (at least for me) that while you are working on a migration, you might want to test it then continue working on it.  Physique provides a convenience task that will run a migration, then immediately roll it back so that you can continue modifying it.
+
+```
+bundle exec rake db:try
+```
+
+## Working With Multiple Databases
+
+Physique also supports solutions with multiple migrations projects.  To configure multiple databases, simply add the migrations projects to your `Rakefile`.  In this hypothetical example, I have configured two migrations projects for a client and server database.
+
+```ruby
+Physique::Solution.new do |s|
+  #...
+  s.fluently_migrate do |db|
+    db.task_alias = 'client'
+    db.instance = ENV['DATABASE_SERVER'] || '(local)'
+    db.name = ENV['DATABASE_NAME_CLIENT'] || 'MyClientDatabase'
+    db.project = 'src/MyProject.Client.Database/MyProject.Client.Database.csproj'
+    db.scripts_dir = '_Scripts'
+  end
+
+  s.fluently_migrate do |db|
+    db.task_alias = 'server'
+    db.instance = ENV['DATABASE_SERVER'] || '(local)'
+    db.name = ENV['DATABASE_NAME_SERVER'] || 'MyServerDatabase'
+    db.project = 'src/MyProject.Server.Database/MyProject.Server.Database.csproj'
+    db.scripts_dir = '_Scripts'
+  end
+end
+```
+
+A couple of things to note here:
+
+* I have specified a task alias for each migrations project.  This alias will be used when constructing your rake task names.  If no alias is provided, the database name is used.
+* I have added some additional environment variables to override the target database server from my continuous integration or deployment builds.
+
+Running `bundle exec rake -T` will now yield:
+
+```
+rake compile                                    # Builds the solution
+rake compile:build                              # Builds the solution using...
+rake compile:clean                              # Builds the solution using...
+rake compile:rebuild                            # Builds the solution using...
+rake db:client:create                           # Create the database
+rake db:client:drop                             # Drop the database
+rake db:client:migrate                          # Migrate database to the l...
+rake db:client:new_migration[name,description]  # Create a new migration fi...
+rake db:client:rebuild                          # Drop and recreate the dat...
+rake db:client:rollback                         # Rollback the database to ...
+rake db:client:seed                             # Seed the database with te...
+rake db:client:setup                            # Create the database and r...
+rake db:client:try                              # Migrate and then immediat...
+rake db:create                                  # Create all databases
+rake db:drop                                    # Drop all databases
+rake db:migrate                                 # Migrates all databases to...
+rake db:rebuild                                 # Drop and recreate all dat...
+rake db:seed                                    # Seed all databases with t...
+rake db:server:create                           # Create the database
+rake db:server:drop                             # Drop the database
+rake db:server:migrate                          # Migrate database to the l...
+rake db:server:new_migration[name,description]  # Create a new migration fi...
+rake db:server:rebuild                          # Drop and recreate the dat...
+rake db:server:rollback                         # Rollback the database to ...
+rake db:server:seed                             # Seed the database with te...
+rake db:server:setup                            # Create the database and r...
+rake db:server:try                              # Migrate and then immediat...
+rake db:setup                                   # Build all databases and m...
+rake restore                                    # Restores all nugets as pe...
+rake test                                       # Run unit tests
+```
+
+We now have tasks that operate on each database individually as well as tasks that operate on all databases at once.
+
+### Database Specific Tasks
+
+The naming convention for db specific tasks is `db:{db_alias}:{task}`.  In this example, if you wanted to rebuild just the client database, you would run the following:
+
+```
+bundle exec rake db:client:rebuild
+```
+
+Some tasks, like `rollback` and `new_migration` only make sense in the context of a specific database, so remember to add the alias to your task name when running them.
+
+```
+bundle exec rake db:client:rollback
+```
+
+### Global Tasks
+
+The following tasks operate on all databases at once.
+
+* `db:create` - Create all databases.
+* `db:drop` - Drop all databases.
+* `db:seed` - Seed all databases with test data.
+* `db:migrate` - Migrate all databases to the latest version.
+* `db:setup` - Create all databases, migrate them to the latest version and populate them with seed data.
+* `db:rebuild` - Drop and setup all databases.
+
+## Happy Migrating!
+
+At this point you should be a Physique migration pro!  Feel free to contact me [@scardetto](https://twitter.com/scardetto) if you have any questions.

data/Gemfile.lock

@@ -1,11 +1,12 @@
 PATH
   remote: .
   specs:
-    physique (0.3.3)
+    physique (0.3.4)
       activesupport (~> 4.1)
       albacore (~> 2.3)
       map (~> 6.5)
       rake (~> 10)
+      semver2 (~> 3.4)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,36 +1,359 @@
-# physique
+# Physique - Beautiful builds for .NET
 
-Beautiful builds for .NET
+Physique is an opinionated build framework that allows you to create a professional build process for your solution with minimal configuration.  You tell physique a little about your solution, and it creates a complete set of rake tasks to build, test and package your apps for deployment.
 
-## Installation
+## Features
 
-Add this line to your application's Gemfile:
+* Integrates with any unit testing framework. Provides built in support for [NUnit](http://www.nunit.org/) and [NSpec](http://nspec.org/).
+* Support for packaging and publishing your assemblies as NuGet packages.
+* Provides powerful developer workflow tools when paired with [FluentMigrator](https://github.com/schambers/fluentmigrator).
+* Built-in support for packaging and publishing applications to [Octopus Deploy](https://octopusdeploy.com/)
+* Built on top of [Albacore](http://github.com/Albacore/albacore) which provides a rich suite of build tools to support any project.
+* Actively maintained with several companies using it in production.
 
-    gem 'physique'
+## Getting Started with Physique
 
-And then execute:
+### Installing Ruby
 
-    $ bundle
+You will need to [install Ruby](RUBY_SETUP.md) on your workstation and build servers.
 
-Or install it yourself as:
+### Project Structure
 
-    $ gem install physique
+Physique was designed to minimize the amount of ceremony in defining a build process.  It uses a set of practical conventions that when followed, eliminate most of the configuration required to set up your builds.
 
-## Usage
+Out of the box, Physique expects your repo to look something like this:
 
-In your project's Rakefile:
+    ├─ build                              # Compiled files
+    │  └─ packages                        # Compiled packages will be built here.
+    ├─ docs                               # Documentation files
+    ├─ lib                                # Included libraries
+    ├─ src                                # Source folder
+    │  ├─ packages                        # Nuget restore location
+    │  ├─ .nuget                          # Nuget files
+    │  │   └─ nuget.exe                   # Nuget executable
+    │  ├─ YourProject                     # Project folder
+    │  │  └─ YourProject.csproj           # Project file
+    │  ├─ YourProject.Tests               # Test Project folder
+    │  │  └─ YourProject.Tests.csproj     # Test Project file
+    │  └─ YourProject.sln                 # Solution file
+    ├─ tools                              # Tools and utilities
+    └─ README.md
+
+If your project doesn't look anything like this, don't worry, you can customize any of the conventions to match the structure of your solution.
+
+### Preparing Your Project
+
+* Open a command prompt and `cd` to the root of your repo.
+
+* Create a `Gemfile` in the root and add the following:
+
+    ```ruby
+    source 'https://rubygems.org/'
+
+    gem 'physique', '~> 0.3'
+    ```
+
+* Install the Bundler gem and install the required Ruby gems
+
+    ```
+    $ gem install bundler
+    $ bundle install
+    ```
+
+* Physique uses the [semver2](https://github.com/haf/semver) gem to manage the version your solution. Use the included command line tool to create a `.semver` file for the solution.
+
+    ```
+    $ bundle exec semver init
+    ```
+
+* Create a `Rakefile` in the root and add the following:
+
+    ```ruby
+    require 'physique'
+
+    Physique::Solution.new do |s|
+      s.file = 'src/YourSolution.sln'
+    end
+    ```
+
+* If everything is set up correctly you should be able to run the following and see a list of tasks that Physique has created for you.
+
+    ```
+    $ bundle exec rake --tasks
+
+    rake compile          # Builds the solution
+    rake compile:build    # Builds the solution using the Build target
+    rake compile:clean    # Builds the solution using the Clean target
+    rake compile:rebuild  # Builds the solution using the Rebuild target
+    rake restore          # Restores all nugets as per the packages.config files
+    rake test             # Run unit tests
+    ```
+
+* Now you can run your rake tasks.  For example, to compile your solution, run the following:
+
+    ```
+    $ bundle exec rake compile
+    ```
+
+## The Default Build Process
+
+Physique's default build process consists of the following phases:
+
+1. `version` - Determines the version of the build.
+2. `restore` - Scans your repo for `packages.config` files and downloads the discovered packages to the Nuget restore location.
+3. `compile` - Runs MSBuild on your solution file.
+4. `test` - Scans your repo for test assemblies and runs all tests.
+5. `package` - Packages your apps and/or assemblies for deployment.
+6. `publish` - Publishes your packages to a Nuget repository.
+
+Each phase depends on the ones before it.  This means when you run the tests, Physique will run the `restore` and `compile` tasks to ensure you your assemblies are up to date.  In addition, you can register custom tasks to run at the different phases of the build process.
+
+## Customizing Your Build
+
+Physique provides several customizations to tailor your build to your needs.  You configure these options in your `Rakefile` which is just a Ruby code file. Having the full power of the Ruby programming language at your disposal to define your builds is one of the best features of rake, and by extension Physique, over XML-based tools like NAnt or MSBuild.  If you don't know Ruby, never fear, Physique's configuration syntax is straightforward enough for any .NET developer to pick up quickly.
+
+The following describes the available configuration options.  Unless otherwise specified, these examples show the default values.
+
+### NuGet Configuration
+
+You can customize how NuGet packages are handled in your solution.
 
 ```ruby
-require 'physique'
+Physique::Solution.new do |s|
+  s.file = 'src/YourSolution.sln'
+
+  s.use_nuget do |n|
+    n.exe = 'src/.nuget/NuGet.exe'          # Path to the NuGet executable
+    n.restore_location = 'src/packages'     # NuGet package restore location
+    n.build_location = 'build/packages'     # Output folder for built NuGet packages
+  end
+end
+```
+
+### Compilation Configuration
 
+You can customize MSBuild configuration and targets.
+
+```ruby
 Physique::Solution.new do |s|
-  s.file = 'src/your-solution.sln'
+  s.file = 'src/YourSolution.sln'
+
+  s.compilation do |c|
+    c.default_targets = ['Clean', 'Rebuild']  # The default targets executed by the 'compile' task
+    c.configuration = 'Release'               # The build configuration
+    c.logging = 'normal'                      # MSBuild logging level
+  end
+end
+```
+
+If you have custom MSBuild targets you can tell Physique about them.
+
+```ruby
+s.compilation do |c|
+  c.add_target 'Custom'
 end
 ```
 
-To view the available `rake` tasks:
+Physique will then add a rake task for each target which you can call from the command line.
+
+```
+$ bundle exec rake compile:custom
+```
+
+By default, Physique will create additional tasks for the Clean, Build and Rebuild targets.
+
+### Unit Testing Configuration
+
+To execute your tests, Physique will look for the test runner executable in the NuGet restore location at runtime. If multiple versions are available, the latest version will be used. Make sure that you include the NuGet package for the test runner in a `packages.config` file somewhere in your solution.
+
+Physique supports NUnit by default, but also has built in support for NSpec.  Each of these test runners have their own defaults.  If you are using something different, it's easy to provide a custom configuration.
+
+#### NUnit Configuration
+
+Since NUnit is the default, no additional configuration is required to use it. Physique will automatically find and run any assembly ending in ".Tests".
+
+To tweak this behavior, you have the following configuration options:
+
+```ruby
+Physique::Solution.new do |s|
+  s.file = 'src/YourSolution.sln'
+
+  s.run_tests do |t|
+    # Find all assemblies ending in '.Tests'
+    t.files = FileList["**/*.Tests/bin/#{configuration}/*.Tests.dll"]
+
+    # Default command line args
+    t.parameters = ['/labels', '/trace=Verbose']
+  end
+end
+```
+
+#### NSpec Configuration
+
+With the NSpec runner configured, Physique will automatically find and run any assembly ending in ".Specs".
+
+Like wth NUnit, you have the following configuration options.  Note the runner must be set to `:nspec`.
+
+```ruby
+Physique::Solution.new do |s|
+  s.file = 'src/YourSolution.sln'
+
+  s.run_tests do |t|
+    t.runner = :nspec
+
+    # The default method for finding NSpec assemblies
+    t.files = FileList["**/*.Specs/bin/#{configuration}/*.Specs.dll"]
+
+    # You can add additional command line args
+    t.parameters = ['--failfast']
+  end
+end
+```
+
+#### Custom Configuration
+
+You can use any unit testing framework. You just need to provide a bit more configuration.
+
+```ruby
+s.run_tests do |t|
+  t.runner = :custom
+
+  # Specify the test runner
+  t.exe = 'root-relative-path/to/the/test-runner.exe'
+
+  # Specify the test assemblies
+  t.files = FileList["**/*.Tests/bin/#{configuration}/*.Tests.dll"]
+
+  # Specify additional command line args
+  t.parameters = ['/option1', '/option2']
+end
+```
+
+### NuGet Publishing Configuration
+
+Physique provides an easy way to publish your NuGet packages to public or private Nuget repos.  Each assembly in your solution will be published as a separate NuGet package with the correct dependencies.
+
+```ruby
+Physique::Solution.new do |s|
+  s.file = 'src/YourSolution.sln'
+
+  s.publish_nugets do |p|
+    # The NuGet repo you want to publish to
+    p.feed_url = 'https://www.nuget.org'
+
+    # The NuGet repo for your symbol package (Optional)
+    p.symbols_feed_url = 'http://nuget.gw.symbolsource.org/Public/NuGet'
+
+    # The API key to authenticate to the repo.
+    # If your source code is public, make sure to pass this in as an environment variable.
+    p.api_key = ENV['NUGET_API_KEY']
+
+    # Metadata to be included in your Nuspec
+    p.with_metadata do |m|
+      m.description = 'Common libraries for crux applications'
+      m.authors = 'Robert Scaduto, Leo Hernandez'
+    end
+  end
+end
+```
+
+When you configure NuGet publishing, the `package` and `publish` tasks become available.
+
+```
+$ bundle exec rake --tasks
+...
+rake nuget:package        # Package all NuGets
+rake nuget:publish        # Publish nuget packages to feed
+rake nuget:publish:local  # Copy nuget packages to local path
+...
+```
+
+## Third Party Tools
+
+### FluentMigrator Configuration
+
+If you are using FluentMigrator to manage your databases, Physique can create several useful tasks to improve your development workflow.  Simply tell Physique where your migrations project is located and it will take care of the rest.
+
+```ruby
+Physique::Solution.new do |s|
+  s.file = 'src/YourSolution.sln'
+
+  s.fluently_migrate do |db|
+    db.instance = '(local)'
+    db.name = 'MyDatabase'
+    db.project = 'src\MyProject.Database\MyProject.Database.csproj'
+  end
+end
+```
+
+Currently Physique only works with SQL Server, but support for additional databases is planned.
+
+For more information, see [Using Physique with Fluent Migrator](FLUENT_MIGRATOR.md)
+
+### Octopus Deploy Configuration
+
+If you are deploying your applications with Octopus Deploy, Physique allows you to package and publish your applications without needing to modify your project file.
+
+```ruby
+Physique::Solution.new do |s|
+  s.file = 'src/YourSolution.sln'
+
+  s.octopus_deploy do |octo|
+    # Octopus Deploy server's NuGet feed URL
+    octo.server = 'http://octopus-deploy-server/nuget/packages'
+
+    # Octopus Deploy API key
+    # For security it's a good idea to pass this in as an environment variable.
+    octo.api_key = ENV['OCTOPUS_API_KEY']
+
+    # You can specify multiple apps to deploy
+
+    # A hypothetical web application
+    octo.deploy_app do |app|
+      # App name for rake tasks
+      app.name = 'web'
+
+      # App type
+      # Valid options include :service, :website, :console
+      app.type = :website
+
+      # App project file
+      app.project = 'src/MyProject.Website/MyProject.Website.csproj'
+
+      # Nuspec metadata for your application
+      app.with_metadata do |m|
+        m.description = 'My Web Application'
+        m.authors = 'My Company, Inc.'
+      end
+    end
+  end
+end
+```
+
+When you configure Octopus deployments, the `octo:package` and `octo:publish` tasks become available.
+
+The following tasks would be available with the configuration above:
+
+```
+$ bundle exec rake --tasks
+...
+rake octo:package       # Package all applications
+rake octo:package:web   # Package MyProject.Website for Oct...
+rake octo:publish       # Publish all apps to Octopus ...
+rake octo:publish:web   # Publish MyProject.Website app to ...
+...
+```
+
+## Roadmap
+
+* Add conventions for more unit test frameworks.
+* Add support for additional databases.
+* Optionally use [Packet](https://github.com/fsprojects/Paket) instead of NuGet during `restore` phase
+* Mono support is possible but completely untested.
+
+## Support
 
-    $ rake --tasks
+Feel free to contact me [@scardetto](https://twitter.com/scardetto) if you have any questions.
 
 ## Contributing