Update: There is also a Part 1 and a Part 3.
Alright, so here is a sample build script for rubicant. First you will have to get rubicant installed. To do that, you need to get the source from https://rubicant.googlecode.com/svn/trunk/. I believe the username is rubicant-read-only.
In the root directory type:
1: E:\projects\rubicant>rake gem
2: (in E:/projects/rubicant)
3: c:/ruby/lib/ruby/gems/1.8/gems/rake-0.8.3/lib/rake/gempackagetask.rb:13:Warning:
4: Gem::manage_gems is deprecated and will be removed on or after March 2009.
5: mkdir -p pkg
6: WARNING: no rubyforge_project specified
7: WARNING: RDoc will not be generated (has_rdoc == false)
8: WARNING: deprecated autorequire specified
9: Successfully built RubyGem
10: Name: Rubicant
11: Version: 0.0.1
12: File: Rubicant-0.0.1.gem
13: mv Rubicant-0.0.1.gem pkg/Rubicant-0.0.1.gem
14:
15: E:\projects\rubicant>
Now you’ve got the gem built, you just need to install it:
1: E:\projects\rubicant>gem install pkg\Rubicant-0.0.1.gem
2: Successfully installed Rubicant-0.0.1
3: 1 gem installed
4:
5: E:\projects\rubicant>
There. Now for a test application. Suppose we’ve got 3 projects that make up a console app. The UI, the Engine (I KNOW) and the Tests. They look like:
For now, let’s ignore the internal workings and focus on building it.
The build script looks like this:
1: require 'rubicant'
2: require 'configatron'
3: include Rubicant
4:
5: BASE_DIR = File.expand_path(".")
6: SRC_DIR = "#{BASE_DIR}/src"
7: SRC_APP_DIR = "#{SRC_DIR}/app"
8: SRC_TEST_DIR = "#{SRC_DIR}/test"
9: CONFIG_DIR = "#{BASE_DIR}/config"
10: BUILD_DIR = "#{BASE_DIR}/build"
11: DEPLOY_DIR = "#{BASE_DIR}/deploy"
12: TOOLS_DIR = "#{BASE_DIR}/tools"
13: MBUNIT_DIR = "#{TOOLS_DIR}/mbunit"
14: RHINO_DIR = "#{TOOLS_DIR}/rhino"
15:
16: UI_SOURCES = FileList["#{SRC_APP_DIR}/Rubicant.Test.App.UI/**/*.cs"]
17: ENGINE_SOURCES = FileList["#{SRC_APP_DIR}/Rubicant.Test.App.Engine/**/*.cs"]
18: TEST_SOURCES = FileList["#{SRC_TEST_DIR}/**/*.cs"]
19:
20: #### Build Initialization
21: task :initialize_build do
22: rm_rf BUILD_DIR if File.exists?(BUILD_DIR)
23: mkdir_p BUILD_DIR
24: rm_rf DEPLOY_DIR if File.exists?(DEPLOY_DIR)
25: mkdir_p DEPLOY_DIR
26: end
27:
28: #### Loading Properties
29: task :load_local_properties do
30: configatron.configure_from_yaml("local.properties.yml")
31: end
32:
33: task :load_test_properties do
34: configatron.configure_from_yaml("test.properties.yml")
35: end
36:
37: #### Deployment Targets
38: task :deploy_local => [:load_local_properties, :deploy]
39:
40: task :deploy_test => [:load_test_properties, :deploy]
41:
42: task :deploy => [:test, :expand_app_config] do
43: cp FileList["#{BUILD_DIR}/{hello.exe,engine.dll}"], DEPLOY_DIR
44: end
45:
46:
47: #### Compile Targets
48: csc :compile, [:initialize_build, :compile_engine], {:files => UI_SOURCES,
49: :target => "exe",
50: :out => "#{BUILD_DIR}/hello.exe",
51: :references => FileList["#{BUILD_DIR}/*.dll"] }
52:
53: csc :compile_engine, [], {:files => ENGINE_SOURCES,
54: :target => "library",
55: :out => "#{BUILD_DIR}/engine.dll"}
56:
57: #### Testing Targets
58: task :test => [:compile_tests, :run_tests]
59:
60: csc :compile_tests, [:compile], {:files => TEST_SOURCES,
61: :target => "library",
62: :out => "#{BUILD_DIR}/tests.dll",
63: :references => FileList["#{BUILD_DIR}/**/*.{dll,exe}", "#{RHINO_DIR}/*.dll", "#{MBUNIT_DIR}/*.dll"]}
64:
65: task :run_tests do
66: mbunit(MBUNIT_DIR, BUILD_DIR, FileList["#{BUILD_DIR}/tests.dll"], {:assembly_path => FileList["#{BUILD_DIR}/engine.dll", "#{RHINO_DIR}/*.dll"].to_a})
67: end
68:
69:
70: #### App.config expansion
71: task :expand_app_config do
72: expand_template "#{CONFIG_DIR}/App.Config.template", "#{DEPLOY_DIR}/hello.exe.config"
73: end
The point of this build file is to be able to churn out two different builds based on two different sets of properties. This is based off of my builds that I do at work where we need to deploy and test in a test environment before going into production. It would be as simple as adding a production.properties.yml and a deploy_production target to simulate this fully in this script.
So basically, we call deploy_test (or deploy_local), which in turn loads the test properties, and then the deploy task.
Deploy calls the test task, which builds the app, builds the tests, runs the tests. If any tests fail, the build will fail here, making sure we don’t deploy any code that doesn’t pass tests.
Finally, we expand our app.config in a way suitable for the environment we’re going into.
Finally, run the executable to see that it worked!
1: E:\projects\Rubicant.Test.App>deploy\hello.exe
2: Hello, World! (Test Version)
3:
4: E:\projects\Rubicant.Test.App>
You can download the source from http://blog.beigesunshine.com/wp-content/uploads/2009/01/rubicanttestapp.zip and try it out for yourself. The default rakefile goes to an exe and an assembly. You can also run both deploy_local and deploy_test and create a single exe file by using rake -f rakefile_single_exe.rb deploy_local.
Coming up, a post on some of the specifics of rubicant.