ot-ios-builder 0.7.9.1

data/CHANGES.md

@@ -0,0 +1,82 @@
+## 0.7.5
+* Allows automation of version/build number setting
+* Adds full paths to xcodebuild and xcrun; they are override-able in the config
+* Adds ability to add arguments to package command
+* Refactors commands and argument code
+* Makes build and signing output optional (use config.verbose to trigger) 
+* Adds simplified output
+* Allows custom SCP ports (@smtlaissezfaire)
+* Fixes Archive task failure (@rennarda)
+* Uses Apple's Packager to produce valid IPAs (@dts)
+* Fixes cases where CFPropertyList could fail to load (@svelix)
+* Uses relative paths for requires (@smtlaissezfaire)
+* Raises an exception if the build fails (@epall)
+
+
+## 0.7.4.1
+* Allow auto-archiving from other Rake namespaces (@victor)
+* Fixed bug with Xcode archive sharing (@victor)
+* Fall back on CFBundleVersion if CFBundleVersionShortString is not set (@subdigital)
+* Added verbose and dry run options to the TestFlight deployment strategy (@subdigital)
+* Defer dynamic release note generation until runtime (@subdigital)
+* Allow architectures to be configured (@subdigital)
+* Fix detection of build directories containing spaces
+
+# 0.7.4
+* YANKED
+
+## 0.7.3
+* Made the Xcode derived data directory more robust by grepping for the Validate line in the log.
+
+## 0.7.2
+* Handle missing values in Xcode archive plist.
+
+## 0.7.1
+* Fixed a problem with detecting the Xcode 4 derived data directory.
+
+## 0.7.0
+* Much improved Xcode 4 support.
+* Generate Xcode 4 style archives using the :xcode4_archive_mode
+* Xcode 4 style archives appear in Xcode organiser complete with your release notes.
+* Added a :skip_clean option to skip cleaning when building
+* Allow the app name to be explicitly set using :app_name
+* WARNING: Xcode 3 support is officially deprecated as of this release!
+
+## 0.6.0
+* Support Xcode 4 workspaces and schemes.
+
+## 0.5.0
+* Support configurable path to xcodebuild executable
+* Support configurable path to Xcode project file
+
+## 0.4
+* If the user has set the EDITOR environment variable, use it to obtain the TestFlight release notes.
+* Bugfix: TestFlight API now returns a 201 Created response when successful.
+* Bugfix: Handle spaces in build artefacts.
+* Updated the default archived build location to match the newest Xcode archived build location.
+
+## 0.3.2
+* Fixed bug #2 (task fails when no testflight distribution list set)
+
+## 0.3.1
+* Separate the :deploy task into :prepare and :deploy tasks.
+
+## 0.3
+* Added support for distribution lists to the TestFlight deployment strategy
+
+## 0.2.1
+* Allow the namespace of generated tasks to be customised
+
+## 0.2
+* Introduced deployment strategies, allowing custom deployment methods
+* Added support for deploying beta releases to TestFlightApp.com
+
+## 0.1.2
+
+* Allow custom hosts when using the SCP deployment task (simonjefford)
+
+## 0.1.1
+* Fixed missing dependency
+
+## 0.1
+* Initial Release

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Luke Redpath
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,248 @@
+# BetaBuilder, a gem for managing iOS ad-hoc builds
+
+BetaBuilder is a simple collection of Rake tasks and utilities for managing and publishing Adhoc builds of your iOS apps. 
+
+If you're looking for the OSX BetaBuilder app -- to which this gem owes most of the credit -- you can find it [here on Github](http://github.com/HunterHillegas/iOS-BetaBuilder).
+
+**Note: As of release 0.7, support for Xcode 3 is deprecated. Xcode 4 has been out for a year, has got much more stable as of 4.1 on Lion (or 4.2 if you've been using the betas) and it's time to move on. Generating Xcode 4 friendly archives and builds in this release still needs a bit of configuration but will become much smoother in 0.8 once Xcode 3 support is removed.**
+
+## Motivation
+
+The problem with using a GUI app to create the beta packages is that it is yet another manual step in the process of producing an ad-hoc build for your beta testers. It simplifies some steps but it still requires running Build and Archive in Xcode, saving the resulting build as an IPA package, running the Beta Builder app, locating the IPA, filling in the rest of the fields and generating the deployment files. Then you need to upload those files somewhere.
+
+As a Ruby developer, I use Rake in most of my projects to run repetitive, often build or test-related tasks and it's equally as useful for non-Ruby projects as it is for Ruby ones.
+
+This simple task library allows you to configure once and then build, package and distribute your ad-hoc releases with a single command.
+
+## Usage
+
+To get started, if you don't already have a Rakefile in the root of your project, create one. If you aren't familiar with Rake, it might be worth [going over some of the basics](http://rake.rubyforge.org/) but it's fairly straightforward.
+
+You can install the BetaBuilder gem from your terminal (OSX 10.6 ships with a perfectly useful Ruby installation):
+
+    $ gem install betabuilder
+
+At the top of your Rakefile, you'll need to require `rubygems` and the `betabuilder` gem (obviously).
+
+    require 'rubygems'
+    require 'betabuilder'
+    
+Because BetaBuilder is a Rake task library, you do not need to define any tasks yourself. You simply need to configure BetaBuilder with some basic information about your project and it will generate the tasks for you. A sample configuration might look something like this:
+
+    BetaBuilder::Tasks.new do |config|
+      # your Xcode target name
+      config.target = "MyGreatApp"
+
+      # the Xcode configuration profile
+      config.configuration = "Adhoc" 
+    end
+    
+Now, if you run `rake -T` in Terminal.app in the root of your project, the available tasks will be printed with a brief description of each one:
+
+    rake beta:build     # Build the beta release of the app
+    rake beta:package   # Package the beta release as an IPA file
+    
+If you use a custom Xcode build directory, rather than the default `${SRCROOT}/build` location, you can configure that too:
+
+    BetaBuilder::Tasks.new do |config|
+      ...
+      config.build_dir = "/path/to/custom/build/dir"
+    end
+
+To deploy your beta to your testers, some additional configuration is needed (see the next section).
+
+Most of the time, you'll not need to run the `beta:build` task directly; it will be run automatically as a dependency of `beta:package`. Upon running this task, your ad-hoc build will be packaged into an IPA file and will be saved in `${PROJECT_ROOT}/pkg/dist`, along with a HTML index file and the manifest file needed for over-the-air installation.
+
+If you are not using the automatic deployment task, you will need to upload the contents of the pkg/dist directory to your server.
+
+To use a namespace other than "beta" for the generated tasks, simply pass in your chosen namespace to BetaBuilder::Tasks.new:
+
+    BetaBuilder::Tasks.new(:my_custom_namespace) do |config|
+    end
+    
+This lets you set up different sets of BetaBuilder tasks for different configurations in the same Rakefile (e.g. a production and staging build).
+
+## Configuration
+A full list of configuration options and their details
+
+`configuration` - (String) The Xcode Configuration to use (Defined on the Info tab of the Project)
+
+`build_dir` - (File Path) The directory the build output will be. (`:derived` for Xcode 4 for versions < 0.8)
+
+`auto_archive` - (true/**false**) Automatically archive when packaging
+
+`archive_path` - (File Path) Path to the Archives
+
+`xcodebuild_path` - (File Path) Path to xcodebuild, if its non-standard
+
+`xcodeargs` - (Arguments) Arguments passed to `xcodebuild` when it runs
+
+`project_file_path` - (File Path) Path to the `.xcodeproj` file
+
+`workspace_path` - (File Path) Path to the `.xcworkspace` file
+
+`ipa_destination_path` - (File Path) Path to output Packaged IPA to
+
+`scheme` - (String) What Scheme to use when building
+
+`app_name` - (String) The name of the app being built (should match the file name, less the `.app` extension)
+
+`arch` - (String) The architecture to build for, if different from project settings
+
+`xcode4_archive_mode` - (true/**false**) Use Xcode4's Archive mode
+
+`skip_clean` - (true/**false**) Skip the clean step when building
+
+`verbose` - (true/**false**) Increased output for debugging
+
+`dry_run` - (true/**false**) Don't upload to Distribution Strategy, just act like it
+
+`set_version_number` - (true/**false**) Attempts to set a version number, see below
+
+### Configuration (Testflight)
+Testflight presents its own set of options that can be configured
+
+`api_token` - (String) Can be your API key, but its recommended to use an `ENV[""]` variable
+
+`team_token` - (String) Your Team's Testflight API token
+
+`distribution_lists` - (Array) A Ruby array (`[1,2]` or `%w{1 2}`) of distribution list names for Testflight
+
+`notify` - (true/**false**) Notify the distribution list of this build
+
+`replace` - (true/**false**) Replace if an existing build exists with the same ID and version
+
+### Configuration (Web)
+Pushing to a web server has the following options.
+
+SSH keys will simplify authentication and make this process seamless
+
+`remote_host` - (String) Hostname for the server the build will be pushed to
+
+`remote_port` - (String) Port Number to use for SCP/SFTP
+
+`remote_installation_path` - (String) Remote Path
+
+### Configuration (RunTime)
+Certain configuration options are availabe at the command line, so that you can temporarily set them for a single run without modifying your configuration.
+
+Pass any of these in as environment variables:
+
+`DRY` - (true/**false**) Enable Dry Run
+`VERBOSE` - (true/**false**) Turn on all output; lets you see the clean, build, and signing output
+`SKIPCLEAN` - (true/**false**) Skips the clean step and goes right to Build.
+
+####Examples
+
+`rake staging:deploy DRY=true`
+
+`rake staging:redeploy VERBOSE=true SKIPCLEAN=true`
+
+## Xcode 4 support
+
+Betabuilder works with Xcode 4, but you may need to tweak your task configuration slightly. The most important change you will need to make is the build directory location, unless you have configured Xcode 4 to use the "build" directory relative to your project, as in Xcode 3.
+
+If you are using the Xcode derived data directory for your builds, then you will need to specify this. Betabuilder will then scan your build log to determine the path to the automatically generated build directory that Xcode is using for your project.
+
+    config.build_dir = :derived
+    
+This will become the default in 0.8.
+
+If you wish to generate archives for your Xcode 4 project, you will need to enable this. This will become the default in future once Xcode 3 support is dropped (deprecated in 0.7):
+
+    config.xcode4_archive_mode = true
+    
+If you are working with an Xcode 4 workspace instead of a project file, you will need to configure this too:
+
+    config.workspace_path = "MyWorkspace.xcworkspace"
+    config.scheme         = "My App Scheme"
+    config.app_name       = "MyApp"
+    set_version_number
+If you are using a workspace, then you must specify the scheme. You can still specify the build configuration (e.g. Release).
+
+## Automatic deployment with deployment strategies
+
+BetaBuilder allows you to deploy your built package using it's extensible deployment strategy system; the gem currently comes with support for simple web-based deployment or uploading to [TestFlightApp.com](http://www.testflightapp.com). Eventually, you will be able to write your own custom deployment strategies if neither of these are suitable for your needs.
+
+## Setting version numbers automatically
+
+You can use betabuilder to set a build number using Git's `describe` system.  In order for that to work, at least one `tag` must exist somewhere in the git hierarchy for the branch being built from. 
+
+Also, you are required to set your `CFBundleVersion` to `${VERSION_LONG}` inside your `Info.plist`.  To accomodate manual builds, add a `VERSION_LONG` Build Setting to your app's Project, and treat it as you normally would your `Info.plist` version number.
+
+Once a tag is created and your App is configured, simply add this to your BetaBuilder config and it will use Git to generate the 
+
+	config.set_version_number = true
+
+It will generate a version number like: `1.0-15-g6b3c1bb`. 
+
+* *1.0* is the most recent tag
+* *15* is the number of commits since the tag was generated
+* *g6b3c1bb* is the beginning of the hash of the last commit.
+
+### Deploying your app with TestFlight
+
+By far the easiest way to get your beta release into the hands of your testers is using the excellent [TestFlight service](http://testflightapp.com/), although at the time of writing it is still in private beta. You can use TestFlight to manage your beta testers and notify them of new releases instantly.
+
+TestFlight provides an upload API and betabuilder uses that to provide a `:testflight` upload strategy. This strategy requires two pieces of information: your TestFlight API token and your team token:
+
+    config.deploy_using(:testflight) do |tf|
+      tf.api_token  = "YOUR_API_TOKEN"
+      tf.team_token = "YOUR_TEAM_TOKEN"
+    end
+    
+Now, instead of using the `beta:package` task, you can run the `beta:deploy` task instead. This task will run the package task as a dependency and upload the generated IPA file to TestFlight. 
+
+You will be prompted to enter the release notes for the build; TestFlight requires these to inform your testers of what has changed in this build. Alternatively, if you have a way of generating the release notes automatically (for instance, using a CHANGELOG file or a git log command), you can specify a block that will be called at runtime - you can do whatever you want in this block, as long as you return a string which will be used as the release notes, e.g.
+
+    config.deploy_using(:testflight) do |tf|
+      ...
+      tf.generate_release_notes do
+        # return release notes here
+      end
+    end
+    
+Finally, you can also specify an array of distribution lists that you want to allow access to the build:
+
+    config.deploy_using(:testflight) do |tf|
+      ...
+      tf.distribution_lists = %w{Testers Internal}
+    end
+
+### Deploying to your own server
+
+BetaBuilder also comes with a rather rudimentary web-based deployment task that uses SCP, so you will need SSH access to your server and appropriate permissions to use it. This works in the same way as the original iOS-BetaBuilder GUI app by generating a HTML template and manifest file that can be uploaded to a directly on your server. It includes links to install the app automatically on the device or download the IPA file.
+
+You will to configure betabuilder to use the `web` deployment strategy with some additional configuration:
+
+    config.deploy_using(:web) do |web|
+      web.deploy_to = "http://beta.myserver.co.uk/myapp"
+      web.remote_host = "myserver.com"
+      web.remote_directory = "/remote/path/to/deployment/directory"
+    end
+    
+The `deploy_to` setting specifies the URL that your app will be published to. The `remote_host` setting is the SSH host that will be used to copy the files to your server using SCP. Finally, the `remote_directory` setting is the path to the location to your server that files will be uploaded to. You will need to configure any virtual hosts on your server to make this work.
+
+## License
+
+This code is licensed under the MIT license.
+
+Copyright (c) 2010 Luke Redpath
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/beta_builder.rb

@@ -0,0 +1,435 @@
+require 'rake/tasklib'
+require 'ostruct'
+require 'fileutils'
+require 'cfpropertylist'
+require File.dirname(__FILE__) + '/beta_builder/archived_build'
+require File.dirname(__FILE__) + '/beta_builder/deployment_strategies'
+require File.dirname(__FILE__) + '/beta_builder/release_strategies'
+require File.dirname(__FILE__) + '/beta_builder/build_output_parser'
+
+module BetaBuilder
+  class Tasks < ::Rake::TaskLib
+    def initialize(namespace = :beta, &block)
+      @configuration = Configuration.new(
+        :configuration => "Adhoc",
+        :build_dir => "build",
+        :xcodebuild_path => "/usr/bin/xcodebuild",
+        :xcrun_path => "/usr/bin/xcrun",
+        :xcodeargs => nil,
+        :packageargs => nil,
+        :project_file_path => nil,
+        :workspace_name => nil,
+        :workspace_path => nil,
+        :ipa_destination_path => "./pkg",
+        :zip_ipa_and_dsym => true,
+        :scheme => nil,
+        :app_name => nil,
+        :arch => nil,
+        :skip_clean => ENV.fetch('SKIPCLEAN', false),
+        :verbose => ENV.fetch('VERBOSE', false),
+        :sdk => "iphoneos",
+        :app_info_plist => nil,
+        :scm => nil,
+        :skip_scm_tagging => true,
+        :skip_version_increment => true,
+        :spec_file => nil
+      )
+      @namespace = namespace
+      yield @configuration if block_given?
+      define
+    end
+
+    def xcodebuild(*args)
+      # we're using tee as we still want to see our build output on screen
+      cmd = []
+      cmd << @configuration.xcodebuild_path
+      cmd.concat args
+      puts "Running: #{cmd.join(" ")}" if @configuration.verbose
+      cmd << "2>&1 %s build.output" % (@configuration.verbose ? '| tee' : '>')
+      cmd = cmd.join(" ")
+      system(cmd)
+    end
+
+    class Configuration < OpenStruct
+      def release_notes_text
+        return release_notes.call if release_notes.is_a? Proc
+        release_notes
+      end
+
+      def build_arguments
+        args = []
+        if workspace_path
+          raise "A scheme is required if building from a workspace" unless scheme
+          args << "-workspace '#{workspace_path}'"
+          args << "-scheme '#{scheme}'"
+        else
+          args << "-target '#{target}'"
+          args << "-project '#{project_file_path}'" if project_file_path
+        end
+
+        args << "-sdk #{sdk}"
+        
+        args << "-configuration '#{configuration}'"
+        args << "-arch '#{arch}'" unless arch.nil?
+        
+        if xcodeargs
+            args.concat xcodeargs if xcodeargs.is_a? Array
+            args << "#{xcodeargs}" if xcodears.is_a? String
+        end
+        
+        args
+      end
+      
+      def app_file_name
+        raise ArgumentError, "app_name or target must be set in the BetaBuilder configuration block" if app_name.nil? && target.nil?
+        if app_name
+          "#{app_name}.app"
+        else
+          "#{target}.app"
+        end
+      end
+      
+      def app_info_plist_path
+        if app_info_plist != nil then 
+          File.expand_path app_info_plist
+        else 
+          nil
+        end
+      end
+
+      def build_number
+        # no plist is found, return a nil version
+        if (app_info_plist_path == nil)  || (!File.exists? app_info_plist_path) then
+          return nil
+        end
+
+        # read the plist and extract data
+        plist = CFPropertyList::List.new(:file => app_info_plist_path)
+        data = CFPropertyList.native_types(plist.value)
+        data["CFBundleVersion"]
+      end
+
+      def next_build_number
+        # if we don't have a current version, we don't have a next version :)
+        if build_number == nil then
+          return nil
+        end
+
+        # get a hold on the build number and increment it
+        version_components = build_number.split(".")
+        new_build_number = version_components.pop.to_i + 1
+        version_components.push new_build_number.to_s
+        version_components.join "."
+      end
+
+      def built_app_long_version_suffix
+        if build_number == nil then
+          ""
+        else 
+          "-#{build_number}"
+        end
+      end
+
+      def ipa_name
+        prefix = app_name == nil ? target : app_name
+        "#{prefix}#{built_app_long_version_suffix}.ipa"
+      end      
+      
+      def built_app_path
+        if build_dir == :derived
+          File.join("#{derived_build_dir}", "#{configuration}-#{sdk}", "#{app_file_name}")
+        else
+          File.join("#{build_dir}", "#{configuration}-#{sdk}", "#{app_file_name}")
+        end
+      end
+      
+      def built_dsym_path
+        "#{built_app_path}.dSYM"
+      end
+      
+      def derived_build_dir 
+        for dir in Dir[File.join(File.expand_path("~/Library/Developer/Xcode/DerivedData"), "#{workspace_name}-*")]
+          return "#{dir}/Build/Products" if File.read( File.join(dir, "info.plist") ).match workspace_path
+        end
+      end
+      
+      
+      def derived_build_dir_from_build_output
+        output = BuildOutputParser.new(File.read("build.output"))
+        output.build_output_dir  
+      end
+
+      def zipped_package_name
+        "#{app_name}#{built_app_long_version_suffix}.zip"
+      end
+
+      def ipa_path
+        File.join(File.expand_path(ipa_destination_path), ipa_name)
+      end
+
+      def dsym_name
+        "#{app_name}#{built_app_long_version_suffix}.dSYM.zip"
+      end
+
+      def dsym_path
+        File.join(File.expand_path(ipa_destination_path), dsym_name)
+      end
+
+      def app_bundle_path
+        "#{ipa_destination_path}/#{app_name}.app"
+      end
+      
+      def deploy_using(strategy_name, &block)
+        if DeploymentStrategies.valid_strategy?(strategy_name.to_sym)
+          self.deployment_strategy = DeploymentStrategies.build(strategy_name, self)
+          self.deployment_strategy.configure(&block)
+        else
+          raise "Unknown deployment strategy '#{strategy_name}'."
+        end
+      end
+
+      def release_using(strategy_name, &block)
+        if ReleaseStrategies.valid_strategy?(strategy_name.to_sym)
+          self.release_strategy = ReleaseStrategies.build(strategy_name, self)
+          self.release_strategy.configure(&block)
+          self.release_strategy.prepare
+        else
+          raise "Unknown release strategy '#{strategy_name}'."
+        end
+      end
+    end
+    
+    private
+    
+    def define
+      namespace(@namespace) do        
+        desc "Clean the Build"
+        task :clean do
+          unless @configuration.skip_clean
+            print "Cleaning Project..."
+            xcodebuild @configuration.build_arguments, "clean"
+            puts "Done"
+          end
+        end
+        
+        desc "Build the beta release of the app"
+        task :build => :clean do
+          print "Building Project..."
+          xcodebuild @configuration.build_arguments, "build"
+          raise "** BUILD FAILED **" if BuildOutputParser.new(File.read("build.output")).failed?
+          puts "Done"
+        end
+        
+        desc "Package the release as a distributable archive"
+        task :package => :build do
+          # there is no need for IPA or dSYM unless we have a device build,
+          # so do that part only on iphoneos SDKs
+          # likewise, there is no need to keep the .app folder around if we're building for ARM
+          # so skip this part on iphoneos SDK
+          if(@configuration.sdk.eql? "iphoneos") then
+            package_ipa
+            package_dsym
+            package_final_artifact
+          else 
+            # clean the pkg folder: create it if it doesn't exist yet
+            FileUtils.mkdir_p @configuration.ipa_destination_path unless  File.exists? @configuration.ipa_destination_path
+            # and remove an existing app_bundle_path if it exists
+            FileUtils.rm_rf @configuration.app_bundle_path unless !File.exists? @configuration.app_bundle_path
+
+            # now we can properly copy the app bundle path over.
+            FileUtils.cp_r @configuration.built_app_path, "#{@configuration.ipa_destination_path}"
+          end
+        end
+
+        desc "Builds an IPA from the built .app"
+        def package_ipa
+          print "Packaging and Signing..."          
+          raise "** PACKAGE FAILED ** No Signing Identity Found" unless @configuration.signing_identity
+          # trash and create the dist IPA path if needed
+          FileUtils.rm_rf @configuration.ipa_destination_path unless !File.exists? @configuration.ipa_destination_path
+          FileUtils.mkdir_p @configuration.ipa_destination_path
+        
+          # Construct the IPA and Sign it
+          cmd = []
+          cmd << @configuration.xcrun_path
+          cmd << "-sdk #{@configuration.sdk}"
+          cmd << "PackageApplication"
+          cmd << "-v '#{@configuration.built_app_path}'"
+          cmd << "-o '#{@configuration.ipa_path}'"
+          cmd << "--sign '#{@configuration.signing_identity}'"
+          cmd << "--embed '#{@configuration.provisioning_profile}'" unless @configuration.signing_identity == nil
+          if @configuration.packageargs then
+            cmd.concat @configuration.packageargs if @configuration.packageargs.is_a? Array
+            cmd << @configuration.packageargs if @configuration.packageargs.is_a? String
+          end
+          puts "Running #{cmd.join(" ")}" if @configuration.verbose
+          cmd << "2>&1 %s build.output" % (@configuration.verbose ? '| tee' : '>')
+          cmd = cmd.join(" ")
+          system(cmd)
+          
+          # zip the dSYM over to the dist folder
+          puts "Done"
+        end
+
+        desc "Zips the dSYM to the package folder"
+        def package_dsym
+          print "Packaging dSYM..."  
+
+          # copy the dSYM to the pkg destination
+          FileUtils.cp_r @configuration.built_dsym_path, @configuration.ipa_destination_path
+
+          # the version is pulled from a path relative location, so fetch BEFORE
+          # we Dir.chdir
+          dsym_name = @configuration.dsym_name
+          dsym_target_path = @configuration.dsym_path
+
+          # move to pkg destination and zip the dSYM
+          current_dir = Dir.pwd
+          Dir.chdir @configuration.ipa_destination_path
+
+          cmd = []
+          cmd << "zip"
+          cmd << "-r"
+          cmd << dsym_target_path
+          cmd << "#{@configuration.app_name}.app.dSYM"
+                  
+          puts "Running #{cmd.join(" ")}" if @configuration.verbose
+          cmd << "2>&1 %s ../build.output" % (@configuration.verbose ? '| tee' : '>')
+          cmd = cmd.join(" ")
+          system(cmd)
+          # back to working directory
+          Dir.chdir current_dir
+        end
+
+        desc "Packages the final artifact (IPA + dSYM)"
+        def package_final_artifact
+          # keep track of current working dir
+          current_dir = Dir.pwd
+          Dir.chdir @configuration.ipa_destination_path
+
+          # zip final package
+          cmd = []
+          cmd << "zip"
+          cmd << @configuration.zipped_package_name
+          cmd << @configuration.dsym_name
+          cmd << @configuration.ipa_name
+          cmd << "2>&1 %s ../build.output" % (@configuration.verbose ? '| tee' : '>')
+          system cmd.join " "
+
+          # delete all the artifacts but the .app. which will be needed by the automation builds
+          File.delete @configuration.dsym_name unless !File.exists? @configuration.dsym_name
+          FileUtils.rm_rf "#{@configuration.app_name}.app.dSYM" unless !File.exists? "#{@configuration.app_name}.app.dSYM"
+
+          # back to working directory
+          Dir.chdir current_dir
+
+          puts "Done"
+          puts "ZIP package: #{@configuration.zipped_package_name}"
+        end
+
+        desc "Tag SCM and prepares for next release (increments build number)"
+        task :release => :package do
+          release
+        end
+
+        desc "For CocoaPod libraries: Tags SCM, pushes to cocoapod and increments build number"
+        task :cocoapod_release => :build do
+          raise "CocoaPod repo is not set, aborting cocoapod_release task." unless @configuration.pod_repo != nil
+          raise "Spec file is not set, aborting cocoapod_release task." unless @configuration.spec_file != nil
+
+          # tag and push current pod
+          @configuration.release_strategy.tag_current_version
+          push_pod
+
+          # increment version numbers
+          if increment_pod_and_plist_number then
+              # and push appropriately
+              @configuration.release_strategy.prepare_for_next_pod_release
+          end
+        end
+
+        def push_pod
+          cmd = []
+          cmd << "pod"
+          cmd << "push"
+          cmd << @configuration.pod_repo
+          # cmd << "--local-only"
+          cmd << "--allow-warnings"
+
+          print "Pushing to CocoaPod..."
+          system (cmd.join " ")
+          puts "Done."
+        end
+
+        def increment_pod_and_plist_number
+          old_build_number = @configuration.build_number
+          if !prepare_for_next_release then 
+            return false
+          end
+
+          # bump the spec version and save it
+          spec_content = File.open(@configuration.spec_file, "r").read
+          old_version = "version = '#{old_build_number}'"
+          new_version = "version = '#{@configuration.build_number}'"
+
+          spec_content = spec_content.sub old_version, new_version
+
+          File.open(@configuration.spec_file, "w") {|f|
+            f.write spec_content
+          }
+
+          true
+        end
+
+        if @configuration.deployment_strategy
+          desc "Prepare your app for deployment"
+          task :deploy_and_release => :package do
+            # deploy first
+            @configuration.deployment_strategy.deploy
+
+            # then release
+            release
+          end
+        end
+
+        def release
+            # tag first, then prepare for next release and 
+            # commit the updated plist
+            if !@configuration.skip_scm_tagging then
+              @configuration.release_strategy.tag_current_version
+            end
+
+            if prepare_for_next_release then
+              @configuration.release_strategy.prepare_for_next_release
+            end
+        end
+
+        def prepare_for_next_release
+          if @configuration.skip_version_increment then
+            return false
+          end
+          
+          next_build_number = @configuration.next_build_number
+          if next_build_number == nil then
+            return false
+          end
+
+          print "Updating #{@configuration.app_info_plist} to version #{next_build_number}"
+
+          # read the plist and extract data
+          plist = CFPropertyList::List.new(:file => @configuration.app_info_plist_path)
+          data = CFPropertyList.native_types(plist.value)
+
+          # re inject new version number into the data
+          data["CFBundleVersion"] = next_build_number
+
+          # recreate the plist and save it
+          plist.value = CFPropertyList.guess(data)
+          plist.save(@configuration.app_info_plist_path, CFPropertyList::List::FORMAT_XML)
+          puts "Done"
+          return true
+        end
+      end
+    end
+  end
+end