mtbuild 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47891c77240ca894e08fc7365e6061070f2cfe04
-  data.tar.gz: debe5f278d337539a7823630ac23a0a7bf667869
+  metadata.gz: 8b0c1036197b946ec76fce626e6318b9ce62c6b5
+  data.tar.gz: f0abf5f39b31506c0a855919937147348540f246
 SHA512:
-  metadata.gz: b32992c59c8222a1ba40ade766e381d98b88e3eac078ee49cd7a336f0af17c02d3f7c6903eba7563c742816f708d436133ce555577116f98b4b50ccca4357b64
-  data.tar.gz: baf679c93b1aa348a2d9cc40d1992b895bf0fa6e3a856354f0bf2a3294c5c1291170ff875fbf0658cd6a3419b7408083ae0b7fec6272cc81ba0cd9a067dec890
+  metadata.gz: b88fcc23e4ffc42f9abc717eec9fc2d66381fa1f98815a168a25589afa2d9d14caa7f010f3305edfccaa3689010c17673687ef6bdbb6fd1fb72a8ae774987eaf
+  data.tar.gz: a270534effc8dc2d446beb07b638e55eca8a1e8ef56519458aacf4f3f90224ec53a1bfb8de9bd2c53297a075f33ba9f51b30488903438f46cf2ad142907e76fc

data/README.md

@@ -1,5 +1,7 @@
 # MTBuild #
 
+[![Gem Version](https://badge.fury.io/rb/mtbuild.svg)](http://badge.fury.io/rb/mtbuild)
+
 MTBuild is MindTribe's Rake-based build system for building C/C++ projects.
 
 MTBuild lives here: https://github.com/MindTribe/MTBuild
@@ -149,7 +151,7 @@ Workspace
 
 #### Projects ####
 
-MTBuild currently defines three types of projects.
+MTBuild currently defines four types of projects.
 
 ##### Application Project #####
 
@@ -163,6 +165,10 @@ A library project defines one or more configurations that contain settings for b
 
 A test application project defines one or more configurations that contain settings for building an executable application that is executed after building. This project type generates Rake tasks for compiling source files, linking them into an executable, and then running the executable. This is intended for building and running unit tests as part of the build process.
 
+##### Framework Project #####
+
+A framework project wraps up a static library and its headers for use by applications. See the "Frameworks" section below for more information.
+
 #### Configurations ####
 
 A configuration containa build settings for a project. This includes source files, toolchain, dependencies, etc. By defining multiple configurations, a project can be built for different processors (ARM, x86, etc.), different platforms, or simply different settings (debug vs. release). Configurations generate the actual Rake tasks that begin doing work. They are named with a fixed convention that allows you to refer to them in other Rake tasks. The naming scheme is "Project:Configuration". For example, if you declare a project called "MyLibrary" with configuration "Debug", you could list "MyLibrary:Debug" as a dependency in any Rake task and "MyLibrary:Debug" would be built before that task.
@@ -199,12 +205,12 @@ workspace :MyWorkspace, File.dirname(__FILE__) do |w|
 end
 
 static_library_project :MyLibrary, File.dirname(__FILE__) do |lib|
+  lib.add_api_headers 'include'
   lib.add_configuration :Debug,
     sources: ['src/**/*.c'],
     toolchain: toolchain(:gcc,
       cflags: '-std=c99',
     )
-    api_headers: 'include'
 end
 ```
 
@@ -223,9 +229,9 @@ workspace :MyLibrary, File.dirname(__FILE__) do |w|
 end
 
 static_library_project :MyLibrary, File.dirname(__FILE__) do |lib|
+  lib.add_api_headers 'include'
   lib.add_configuration :Debug,
-    sources: ['src/**/*.c'],
-    api_headers: 'include'
+    sources: ['src/**/*.c']
 end
 ```
 
@@ -235,9 +241,9 @@ Configurations can list dependencies that will be built before the configuration
 
 #### Automatic Library Dependencies ####
 
-MTBuild library projects allow you to specify API header locatinos for library project configurations. If you list a library project as a dependency of an application project, MTbuild will automatically include the library's API header paths when compiling the application. Additionally, it will automatically link the application with the library. This is intended to facilitate the scenario where you're building both a library and an application from a Workspace. To use the library from the application, you simply need to list the library as a dependency and MTBuild will make sure the application can use it.
+MTBuild library projects allow you to specify API header locations for framework and static library project configurations. If you list a framework or a static library project as a dependency of an application project, MTbuild will automatically include the framework or library's API header paths when compiling the application. Additionally, it will automatically link the application with the framework or library. This is intended to facilitate the scenario where you're building both a library and an application from a Workspace. To use the library from the application, you simply need to list the library as a dependency and MTBuild will make sure the application can use it.
 
-Note that this does not work with non-MTBuild libraries. If you list a non-MTBuild Rake library task as a dependency of a MTBuild project, you will need to manually add the library's headers and library file to the project.
+Note that this does not work with non-MTBuild libraries. If you list a non-MTBuild Rake library task as a dependency of a MTBuild project, you will need to manually add the library's headers and library file to the project. If you have a precompiled 3rd-party library, you might consider wrapping it in a framework project so that you can use the Automatic Library Dependencies mechanism.
 
 ###### Automatic Library Dependencies Example #####
 
@@ -258,9 +264,9 @@ This defines a library with one configuration called "Debug". The library's API
 
 ```Ruby
 static_library_project :MyLibrary, File.dirname(__FILE__) do |lib|
+  lib.add_api_headers 'include'
   lib.add_configuration :Debug,
     sources: ['src/**/*.c'],
-    api_headers: 'include',
     toolchain: toolchain(:gcc)
 end
 ```
@@ -283,6 +289,10 @@ application_project :MyApp, File.dirname(__FILE__) do |app|
 end
 ```
 
+#### Frameworks ####
+
+MTBuild Frameworks contain pre-compiled objects/libraries and their headers. MTBuild Frameworks generate tasks that don't do anything; however, applications can list Framework configurations as dependencies to take advantage of Automatic Library Dependencies.
+
 #### Toolchains ####
 
 MTBuild Toolchains generate the individual compile, archival, and link tasks that comprise an application or library. Most of the interesting settings in a project's configuration go in the toolchain. The settings vary based upon the toolchain.
@@ -415,12 +425,14 @@ For ```configuration_block```, you supply a block that takes one parameter. When
 #### add_configuration ####
 Use ```add_configuration(configuration_name, configuration)``` inside of a static library project configuration block to add a build configuration for the library. The ```configuration_name``` parameter expects a symbol that serves as a human-readable name for the configuration. Rake tasks related to this configuration will be namespaced with this symbol. For example, the top-level Rake task for building the "Debug" configuration of "MyLibrary" would be "MyLibrary:Debug". The ```configuration``` parameter expects a hash that contains settings for the configuration.
 
-##### Static Library Project configuration settings #####
-Static Library Project configurations use the same settings as Application Project configurations.
+#### add_api_headers ####
+Use ```add_api_headers(api_headers)``` inside of a static library project configuration block--before adding configurations--to set the location(s) of the library's API headers. The ```api_headers``` parameter should be one or more API header paths. For example, ```'include'``` or ```['include', 'plugins']```. Note that the API header paths should be relative to the project folder. API header paths should NOT contain one another. For example, do not do this: ```['include', 'include/things']```. You can have subfolders inside of an API header location, but you should only add the topmost folder.
 
-Additionally, Static Library Project configurations offer the following optional settings:
+#### build_framework_package ####
+Use ```build_framework_package(configuration_names)``` inside of a static library project configuration block to specify that the library should provide a framework package target. Use ```configuration_names``` to provide a list of configuration names to include in the package. For example, ```'Configuration1'``` or ```['Configuration1', 'Configuration2']```.
 
-* ```:api_headers``` - One or more API header paths. For example, ```'include'``` or ```['include', 'include/plugins']```. Note that the API header paths should be relative to the project folder.
+##### Static Library Project configuration settings #####
+Static Library Project configurations use the same settings as Application Project configurations.
 
 ### MTBuild::TestApplicationProject ###
 Define a Test Application Project with the following DSL method:
@@ -441,6 +453,33 @@ Use ```add_configuration(configuration_name, configuration)``` inside of a test
 ##### Test Application Project configuration settings #####
 Test Application Project configurations use the same settings as Application Library Project configurations.
 
+### MTBuild::FrameworkProject ###
+
+Define a Framework Project with the following DSL method:
+
+```Ruby
+framework_project(framework_name, project_folder, &configuration_block)
+```
+
+```framework_name``` is your desired name for the framework. This should be a symbol such as ```:MyApplication```. It serves as a human-readable name for the framework. Rake tasks related to this framework will be namespaced with this symbol. For example, the top-level Rake task for building the "MyLibrary" framework with a configuration called "Debug" would be "MyLibrary:Debug".
+
+```project_folder``` is the location of the project. Project files should be located at or below this location. Typically, you'd simply pass ```File.dirname(__FILE__)``` to use the same folder as the project's Rakefile.
+
+For ```configuration_block```, you supply a block that takes one parameter. When MTBuild invokes the block, it will pass an FrameworkProject object as this parameter. Inside the block, you can make FrameworkProject calls on this object to add configurations.
+
+#### add_configuration ####
+Use ```add_configuration(configuration_name, configuration)``` inside of a framework project configuration block to add a configuration for the framework. The ```configuration_name``` parameter expects a symbol that serves as a human-readable name for the configuration. Rake tasks related to this configuration will be namespaced with this symbol. For example, the top-level Rake task for building the "Debug" configuration of "MyLibrary" would be "MyLibrary:Debug". The ```configuration``` parameter expects a hash that contains settings for the configuration.
+
+#### add_api_headers ####
+Use ```add_api_headers(api_headers)``` inside of a framework project configuration block--before adding configurations--to set the location(s) of the framework's API headers. The ```api_headers``` parameter should be one or more API header paths. For example, ```'include'``` or ```['include', 'plugins']```. Note that the API header paths should be relative to the project folder. API header paths should NOT contain one another. For example, do not do this: ```['include', 'include/things']```. You can have subfolders inside of an API header location, but you should only add the topmost folder.
+
+##### Framework Project configuration settings #####
+Framework Project configurations use the same settings as Application Project configurations.
+
+Additionally, Framework Project configurations require the following settings:
+
+* ```:objects``` - One or more framework object files. For example, ```'MyLibrary.a'```
+
 ### MTBuild::Toolchain ###
 Define a Toolchain with the following DSL method:
 

data/lib/mtbuild.rb

@@ -4,6 +4,8 @@ require "mtbuild/application"
 require "mtbuild/application_project"
 require "mtbuild/application_task"
 require "mtbuild/dsl"
+require "mtbuild/framework_project"
+require "mtbuild/framework_task"
 require "mtbuild/mtbuild"
 require "mtbuild/staticlibrary_project"
 require "mtbuild/staticlibrary_task"

data/lib/mtbuild/application_configuration.rb

@@ -1,5 +1,6 @@
 module MTBuild
   require 'mtbuild/compiled_configuration'
+  require 'mtbuild/organized_package_task'
 
   # Use this class to create application configurations. You won't typically
   # instantiate this directly. Instead, the ApplicationProject.add_configuration
@@ -31,6 +32,15 @@ module MTBuild
           end
         end
       end
+
+      namespace @configuration_name do
+        OrganizedPackageTask.new("#{@project_name}-#{@configuration_name}", :noversion) do |t|
+          t.need_tar_gz = true
+          t.add_files_to_folder("", application_binaries+application_files)
+        end
+      end
+      Rake::Task[:"#{@project_name}:#{@configuration_name}:package"].prerequisites.insert(0, :"#{@project_name}:#{@configuration_name}")
+
     end
 
 	end

data/lib/mtbuild/dsl.rb

@@ -12,6 +12,11 @@ module MTBuild
       MTBuild::ApplicationProject.new(application_name, project_folder, &configuration_block)
     end
 
+    # Defines a FrameworkProject
+    def framework_project(framework_name, project_folder, &configuration_block)
+      MTBuild::FrameworkProject.new(framework_name, project_folder, &configuration_block)
+    end
+
     # Defines a StaticLibraryProject
     def static_library_project(library_name, project_folder, &configuration_block)
       MTBuild::StaticLibraryProject.new(library_name, project_folder, &configuration_block)

data/lib/mtbuild/framework_configuration.rb

@@ -0,0 +1,36 @@
+module MTBuild
+  require 'mtbuild/configuration'
+
+  # Use this class to create framework configurations. You won't typically
+  # instantiate this directly. Instead, the FrameworkProject.add_configuration
+  # method will create this for you.
+  class FrameworkConfiguration < Configuration
+
+    def initialize(project_name, project_folder, output_folder, configuration_name, configuration, api_headers)
+      super project_name, project_folder, output_folder, configuration_name, configuration
+      check_configuration(configuration)
+      @object_files = Utils.expand_file_list(configuration[:objects], [], @project_folder)
+      @api_headers = api_headers
+    end
+
+    # Create the actual Rake tasks that will perform the configuration's work
+    def configure_tasks
+      super
+      desc "Framework '#{@project_name}' with configuration '#{@configuration_name}'"
+      new_task = framework_task @configuration_name => @object_files do |t|
+        puts "found framework #{t.name}."
+      end
+      new_task.api_headers = @api_headers
+      new_task.library_files = @object_files
+    end
+
+    private
+
+    def check_configuration(configuration)
+      super
+      fail "No objects specified for #{@project_name}:#{@configuration_name}" if configuration.fetch(:objects, nil).nil?
+    end
+
+  end
+
+end

data/lib/mtbuild/framework_project.rb

@@ -0,0 +1,33 @@
+module MTBuild
+  require "mtbuild/framework_configuration"
+  require 'mtbuild/project'
+
+  # This class is used to load frameworks. A framework provides precompiled
+  # objects/libraries and API headers. Listing a framework as a dependency in
+  # an application will automatically include the framework's API headers and
+  # link with its objects/libraries
+  class FrameworkProject < Project
+
+    def initialize(project_name, project_folder, &configuration_block)
+      @api_headers = []
+      super
+    end
+
+    # Adds a named FrameworkConfiguration to the project.
+    def add_configuration(configuration_name, configuration)
+      super
+      default_configuration = Workspace.configuration_defaults.fetch(configuration_name, {})
+      merged_configuration = Utils.merge_configurations(default_configuration, configuration)
+      cfg = FrameworkConfiguration.new(@project_name, @project_folder, effective_output_folder, configuration_name, merged_configuration, @api_headers)
+      @configurations << cfg
+      return cfg
+    end
+
+    # Specifies API header locations
+    def add_api_headers(api_headers)
+      @api_headers += Utils.expand_folder_list(api_headers, @project_folder)
+    end
+
+  end
+
+end

data/lib/mtbuild/framework_task.rb

@@ -0,0 +1,31 @@
+module Rake
+
+  require 'rake'
+
+  # This is a top-level Rake task for loading a framework
+  class FrameworkTask < Task
+
+    # API header location for the framework
+    attr_accessor :api_headers
+
+    # The framework objects
+    attr_accessor :library_files
+
+    def initialize(task_name, app)
+      super
+      @api_headers = ''
+      @library_files = ''
+    end
+
+  end
+
+  module DSL
+
+    # DSL method to create a framework task.
+    def framework_task(*args, &block)
+      new_task = Rake::FrameworkTask.define_task(*args, &block)
+    end
+
+  end
+
+end

data/lib/mtbuild/organized_package_task.rb

@@ -0,0 +1,145 @@
+module MTBuild
+
+  require 'rake'
+  require 'rake/packagetask'
+  require 'pathname'
+
+  # Create a packaging task that will package files into distributable packages
+  # (e.g zip archive or tar files). The files are organized in folders inside the
+  # package.
+  #
+  # The OrganizedPackageTask will create the following targets:
+  #
+  # +:package+ ::
+  #   Create all the requested package files.
+  #
+  # +:clobber_package+ ::
+  #   Delete all the package files.  This target is automatically
+  #   added to the main clobber target.
+  #
+  # +:repackage+ ::
+  #   Rebuild the package files from scratch, even if they are not out
+  #   of date.
+  #
+  # <tt>"<em>package_dir</em>/<em>name</em>-<em>version</em>.tgz"</tt> ::
+  #   Create a gzipped tar package (if <em>need_tar</em> is true).
+  #
+  # <tt>"<em>package_dir</em>/<em>name</em>-<em>version</em>.tar.gz"</tt> ::
+  #   Create a gzipped tar package (if <em>need_tar_gz</em> is true).
+  #
+  # <tt>"<em>package_dir</em>/<em>name</em>-<em>version</em>.tar.bz2"</tt> ::
+  #   Create a bzip2'd tar package (if <em>need_tar_bz2</em> is true).
+  #
+  # <tt>"<em>package_dir</em>/<em>name</em>-<em>version</em>.zip"</tt> ::
+  #   Create a zip package archive (if <em>need_zip</em> is true).
+  #
+  # Example:
+  #
+  #   Rake::OrganizedPackageTask.new("MyPackage", "1.2.3") do |p|
+  #     p.need_tar = true
+  #     p.add_files_to_folder('bin', 'bin', '**/*')
+  #     p.package_files.include("lib/**/*.rb")
+  #   end
+  #
+  class OrganizedPackageTask < Rake::PackageTask
+
+    # Add files to a folder in the package
+    def add_files_to_folder(package_folder, included_files, excluded_files=[])
+      file_list = Utils.expand_file_list(included_files, excluded_files)
+      package_file_list = file_list.collect{ |f| File.join(package_dir_path, package_folder, File.basename(f)) }
+      @origin_files += file_list
+      @destination_files += package_file_list
+    end
+
+    # Add folder to a folder in the package
+    def add_folders_to_folder(package_folder, folders, excluded_files=[])
+      folders.each do |folder|
+        file_list = Utils.expand_file_list('/**/*', excluded_files, folder)
+        package_file_list = file_list.collect{ |f| File.join(package_dir_path, package_folder, get_relative_path(folder,f)) }
+        @origin_files += file_list
+        @destination_files += package_file_list
+      end
+    end
+
+    # Hide the PackageTask package_files because this class doesn't use it
+    private :package_files
+
+    private
+
+    def init(name, version)
+      super
+      fail "Version required (or :noversion)" if @version.nil?
+      @version = nil if :noversion == @version
+      @destination_files = []
+      @origin_files = []
+    end
+
+    def get_relative_path(parent, child)
+      child = Pathname.new(child)
+      parent = Pathname.new(parent)
+      return child.relative_path_from(parent).to_s
+    end
+
+    def define
+      desc "Build the package"
+      task :package
+
+      desc "Force a rebuild of the package files"
+      task :repackage => [:clobber_package, :package]
+
+      desc "Remove package products"
+      task :clobber_package do
+        rm_r package_dir rescue nil
+      end
+
+      task :clobber => [:clobber_package]
+
+      [
+        [need_tar, tgz_file, "z"],
+        [need_tar_gz, tar_gz_file, "z"],
+        [need_tar_bz2, tar_bz2_file, "j"]
+      ].each do |(need, file, flag)|
+        if need
+          task :package => ["#{package_dir}/#{file}"]
+          file "#{package_dir}/#{file}" =>
+            [package_dir_path] + @origin_files + @destination_files do
+            chdir(package_dir) do
+              sh %{#{@tar_command} #{flag}cvf #{file} #{package_name}}
+            end
+          end
+        end
+      end
+
+      if need_zip
+        task :package => ["#{package_dir}/#{zip_file}"]
+        file "#{package_dir}/#{zip_file}" =>
+          [package_dir_path] + @origin_files + @destination_files do
+          chdir(package_dir) do
+            sh %{#{@zip_command} -r #{zip_file} #{package_name}}
+          end
+        end
+      end
+
+      directory package_dir_path
+
+      @destination_files.each_index do |i|
+        origin_file = @origin_files[i]
+        destination_file = @destination_files[i]
+
+        file destination_file => [origin_file, package_dir_path] do
+          fdir = File.dirname(destination_file)
+          mkdir_p(fdir) unless File.exist?(fdir)
+          if File.directory?(origin_file)
+            mkdir_p(destination_file)
+          else
+            rm_f destination_file
+            safe_ln(origin_file, destination_file)
+          end
+        end
+      end
+
+      self
+    end
+  end
+
+end

data/lib/mtbuild/project.rb

@@ -61,10 +61,6 @@ module MTBuild
     def add_configuration(configuration_name, configuration)
     end
 
-    def create_configuration_tasks(configuration_name, configuration)
-      check_configuration(configuration_name, configuration)
-    end
-
     include Rake::DSL
 	end
 

data/lib/mtbuild/staticlibrary_configuration.rb

@@ -6,12 +6,9 @@ module MTBuild
   # method will create this for you.
 	class StaticLibraryConfiguration < CompiledConfiguration
 
-    # API header location for the static library
-    attr_reader :api_headers
-
-    def initialize(project_name, project_folder, output_folder, configuration_name, configuration)
-      super
-      @api_headers = Utils.expand_folder_list(configuration.fetch(:api_headers, []), @project_folder)
+    def initialize(project_name, project_folder, output_folder, configuration_name, configuration, api_headers)
+      @api_headers = api_headers
+      super project_name, project_folder, output_folder, configuration_name, configuration
     end
 
     # Create the actual Rake tasks that will perform the configuration's work

data/lib/mtbuild/staticlibrary_project.rb

@@ -1,21 +1,84 @@
 module MTBuild
   require "mtbuild/staticlibrary_configuration"
+  require 'mtbuild/organized_package_task'
   require 'mtbuild/project'
 
   # This class is used to build static libraries. A static library has
   # compilation and archival phases that produce a binary library package.
 	class StaticLibraryProject < Project
 
+    def initialize(project_name, project_folder, &configuration_block)
+      @framework_configurations = []
+      @api_headers = []
+      super
+      if @framework_configurations.count > 0
+        configure_framework_tasks
+      end
+    end
+
     # Adds a named static library configuration to the project.
     def add_configuration(configuration_name, configuration)
       super
       default_configuration = Workspace.configuration_defaults.fetch(configuration_name, {})
       merged_configuration = Utils.merge_configurations(default_configuration, configuration)
-      cfg = StaticLibraryConfiguration.new(@project_name, @project_folder, effective_output_folder, configuration_name, merged_configuration)
+      cfg = StaticLibraryConfiguration.new(@project_name, @project_folder, effective_output_folder, configuration_name, merged_configuration, @api_headers)
       @configurations << cfg
       return cfg
     end
 
+    # Provides a framework package target that builds a framework package with the specified configurations
+    def build_framework_package(configuration_names)
+      @framework_configurations += Utils.ensure_array(configuration_names)
+    end
+
+    # Specifies API header locations
+    def add_api_headers(api_headers)
+      @api_headers += Utils.expand_folder_list(api_headers, @project_folder)
+    end
+
+    private
+
+    def configure_framework_tasks
+      namespace @project_name do
+        framework_task = OrganizedPackageTask.new("#{@project_name}", :noversion) do |t|
+          t.need_tar_gz = true
+          t.add_folders_to_folder("Headers", @api_headers)
+          @framework_configurations.each do |framework_configuration|
+            configuration_name = "#{@project_name}:#{framework_configuration}"
+            configuration_task = Rake.application.lookup(configuration_name)
+            fail "Unable to locate configuration: #{configuration_name}" if configuration_task.nil?
+            fail "Configuration is not a library configuration: #{configuration_name}" unless configuration_task.respond_to? :library_files
+
+            t.add_files_to_folder("Libraries/#{framework_configuration}", configuration_task.library_files)
+          end
+        end
+
+        framework_rakefile = File.join(framework_task.package_dir_path, "Rakefile.rb")
+        file framework_rakefile do |f|
+          fdir = File.dirname(framework_rakefile)
+          mkdir_p(fdir) unless File.exist?(fdir)
+
+          File.open(framework_rakefile, 'w') do |f|
+            f.puts("framework_project :#{@project_name}, File.dirname(__FILE__) do |lib|")
+            f.puts("  lib.add_api_headers 'Headers'")
+            @framework_configurations.each do |framework_configuration|
+              configuration_name = "#{@project_name}:#{framework_configuration}"
+              configuration_task = Rake.application.lookup(configuration_name)
+              f.puts("  lib.add_configuration :#{framework_configuration},")
+              f.puts("    objects: ['Libraries/#{framework_configuration}/*']")
+            end
+            f.puts("end")
+          end
+        end
+
+        @framework_configurations.each do |framework_configuration|
+          Rake::Task[:"#{@project_name}:package"].prerequisites.insert(0, :"#{@project_name}:#{framework_configuration}")
+          Rake::Task[:"#{@project_name}:package"].prerequisites.insert(0, framework_rakefile)
+        end
+
+      end
+    end
+
 	end
 
 end

data/lib/mtbuild/version.rb

@@ -1,4 +1,4 @@
 module MTBuild
   # The current MTBuild version.
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mtbuild
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Jerry Ryle
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-18 00:00:00.000000000 Z
+date: 2014-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -107,7 +107,11 @@ files:
 - lib/mtbuild/compiled_configuration.rb
 - lib/mtbuild/configuration.rb
 - lib/mtbuild/dsl.rb
+- lib/mtbuild/framework_configuration.rb
+- lib/mtbuild/framework_project.rb
+- lib/mtbuild/framework_task.rb
 - lib/mtbuild/mtbuild.rb
+- lib/mtbuild/organized_package_task.rb
 - lib/mtbuild/project.rb
 - lib/mtbuild/staticlibrary_configuration.rb
 - lib/mtbuild/staticlibrary_project.rb
@@ -138,7 +142,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='