xcoder 0.1.15 → 0.1.18

data/.gitignore

@@ -23,3 +23,9 @@ spec/TestProject/TestProject.xcodeproj/project.xcworkspace/
 spec/TestProject/build
 spec/test-reports
 
+# local vendor/bundle 
+vendor/bundle/*
+
+# RubyMine project
+.idea/*
+

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.3-p392

data/.rvmrc

@@ -1,4 +1,4 @@
-rvm use 1.9.2@xcoder
+rvm use 1.9.3@xcoder
 rvm_install_on_use_flag=1
 rvm_project_rvmrc=1
 rvm_gemset_create_on_use_flag=1

data/Gemfile

@@ -4,14 +4,22 @@ gemspec
 gem 'rake'
 
 gem 'builder'
-gem 'json'
+gem 'multi_json'
 gem 'plist'
 gem 'rest-client'
+
+# Documentation
 gem 'yard'
+gem 'redcarpet'
+
+# Deployment
+gem 'net-ssh'
+gem 'net-scp'
+gem 'aws-sdk'
 
 group :test do
   gem 'rspec'
   gem 'guard'
   gem 'guard-rspec'
   gem 'ruby-debug19'
-end
+end

data/README.md

@@ -8,7 +8,7 @@ Full documentation can be found here: http://rayh.github.com/xcoder/
 
 ## Requirements
 
-Xcoder assumes you are using XCode 4.3 on Lion and ruby 1.9.  You may have some degree of success with lesser versions, but they are not intentionally supported.
+Xcoder assumes you are using XCode 4.6 on Mountain Lion and ruby 1.9.  You may have some degree of success with lesser versions, but they are not intentionally supported.
 
 ## Example Usage
 
@@ -84,6 +84,23 @@ This will produce something like: MyProject-Debug-1.0.ipa and MyProject-Debug-1.
 	  info.save
 	end
 
+### Managing build numbers more efficiently
+
+Based on our experience we suggest [Versionomy](https://github.com/dazuma/versionomy) to manage version numbers. 
+Although the marketing version is usually set by hand on release, 
+there are situations where it could be nice to have an incremental build number in the marketing version number as well.
+The following is an example that takes a marketing version number in the x.y.z format and increments the last part of it.
+
+	config.info_plist do |info|
+  	  info.version = info.version.to_i + 1
+  	  marketing_version = Versionomy.parse(info.marketing_version)
+  	  info.marketing_version = marketing_version.bump(:tiny).to_s
+  	  info.save
+	end
+
+You can read more about Versionomy at their [site](https://github.com/dazuma/versionomy)
+
+
 ### Working with workspaces
 
 Loading workspaces can be done in a similar way to projects:
@@ -118,7 +135,8 @@ Note: Shared schemes and user (current logged in user) specific schemes are both
 
 The library provides a mechanism to install/uninstall a provisioning profile.  This normally happens as part of a build (if a profile is provided to the builder, see above), but you can do this manually:
 
-	Xcode::ProvisioningProfile.new("Myprofile.mobileprovision").install	# installs profile into ~/Library
+	# installs profile into ~/Library
+	Xcode::ProvisioningProfile.new("Myprofile.mobileprovision").install	
 
 Or enumerate installed profiles:
 
@@ -126,18 +144,59 @@ Or enumerate installed profiles:
 		p.uninstall		# Removes the profile from ~/Library/
 	end
 
-### [Testflight](http://testflightapp.com)
+### Deployment
+
+#### [Testflight](http://testflightapp.com)
 
 The common output of this build/package process is to upload to Testflight.  This is pretty simple with Xcoder:
 
-	builder.testflight(API_TOKEN, TEAM_TOKEN) do |tf|
-	  tf.notes = "some release notes"
- 	  tf.notify = true	# Whether to send a notification to users, default is true
-      tf.lists << "AList"  # The lists to distribute the build to
-	end
+	# Optionally do this, saves doing it again and again
+	Xcode::Deploy::Testflight.defaults :api_token => 'some api token', :team_token => 'team token'
+
+	builder.deploy :testflight,
+		:api_token 	=> API_TOKEN, 
+		:team_token => TEAM_TOKEN,
+		:notes 		=> "some release notes",
+ 	  	:notify 	=> true,		# Whether to send a notification to users, default is true
+      	:lists 		=> ["AList"]  	# The lists to distribute the build to
+
+You can also optionally set the HTTP_PROXY environment variable.
+
+#### Deploying to Amazon S3
+
+You can upload the output ipa to an arbitrary buckey on S3
+
+	builder.deploy :s3, 
+		:bucket => "mybucket", 
+		:access_key_id => "access id", 
+		:secret_access_key => "access key", 
+		:dir => "options/path/within/bucket"
+
+#### Deploying to a web server (SSH)
+
+The output of the build/package process can be deployed to a remote web server.
+You can use SSH with the following syntax:
 
-You can also optionally set a .proxy= property or just set the HTTP_PROXY environment variable.
+	builder.deploy :ssh, 
+		:host => "mywebserver.com", 
+		:username => "myusername", 
+		:password => "mypassword", 
+		:dir => "/var/www/mywebserverpath",
+		:base_url => "http://mywebserver.com/"
 
+#### Deploying to a web server (FTP)
+
+The output of the build/package process can be deployed to a remote web server.
+You can upload the files through FTP with the following syntax:
+
+	builder.deploy :ftp, 
+		:host => "ftp.mywebserver.com", 
+		:username => "myusername", 
+		:password => "mypassword", 
+		:dir => "/mywebserverpath",
+		:base_url => "http://mywebserver.com/"
+
+	
 ### OCUnit to JUnit reports
 
 You can invoke your test target/bundle from the builder
@@ -308,6 +367,48 @@ There are some basic RSpec tests in the project which I suspect /wont/ work on m
 
 Currently these tests only assert the basic project file parsing and build code and do not perform file modification tests (e.g. for info plists) or provisioning profile/keychain importing
 
+## Automation and CI (BETA)
+
+NOTE: This is only available in HEAD, you will need to install this gem from source to get this Buildspec support and the xcoder tool
+
+This stuff is a work-in-progress and is subject to change.
+
+Xcoder provides a simple mechanism to help with automating builds and CI.  First, define a Buildspec file in the root of your project with contents like this:
+
+	# Assumes identity is first in keychain
+	group :adhoc do
+
+	  # Which project/target/config, or workspace/scheme to use
+	  use :MyProject, :target => :MyTarget, :config => :Release
+	    
+	  # The mobile provision that should be used
+	  profile 'Provisioning/MyProject_AdHoc.mobileprovision'
+
+	  # Keychain is option, allows isolation of identities per-project without 
+	  # poluting global keychain
+	  keychain 'Provisioning/build.keychain', 'build'
+	  
+	  deploy :testflight, 
+	    :api_token => 'api token', 
+	    :team_token => 'team token',
+	    :notify => true, 
+	    :lists => ['Internal'], 
+	    :notes => `git log -n 1`
+	end
+
+You can then invoke the project using the xcoder command line:
+
+	# Invoke the default task (deploy)
+	xcoder -r
+
+	# Invoke a specific task
+	xcoder -r adhoc:package
+
+	# Get a list of tasks
+	xcoder -T
+
+This is a bit of a work-in-progress and an attempt to allow projects to provide a minimal declaration of how thier artifacts should be built and where they should go.  Integration with CI (Jenkins, for example) or just running locally from the command line should be simple.
+
 ## Feedback
 
 Please raise issues if you find defects or have a feature request.

data/Rakefile

@@ -10,7 +10,7 @@ task :specs do
 end
 
 desc "Run integration tests"
-task :integration do
+task :integration => :reset do
   system "rspec --color --format d --tag integration"
 end
 
@@ -28,7 +28,7 @@ namespace :test_project do
   
   task :reset do
     puts "Reseting the TestProject Project File"
-    system "git co -- spec/TestProject"
+    system "git checkout -- spec/TestProject"
     puts "Removing any User schemes generated in the project"
     system "rm -rf spec/TestProject/TestProject.xcodeproj/xcuserdata"
     puts "Removing any installed files"

data/bin/xcoder

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+require 'xcoder'
+require 'optparse'
+
+require 'xcode/buildspec'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: xcoder [options]"
+
+
+  opts.separator ""
+  opts.separator "Specific options:"
+
+  opts.on("-d", "--describe", "Dump the structure of the projects/workspaces in the working directory") do |v|
+  	Xcode.workspaces.each do |w|
+	    puts w.describe
+	  end
+	  
+	  Xcode.projects.each do |p|
+	    puts p.describe
+	  end
+    # options[:verbose] = v
+  end
+
+  opts.on("--install-profile [PROFILE]", "Install the given profile into ~/Library") do |profile|
+  	Xcode::ProvisioningProfile.new(profile).install
+  end
+  
+  opts.on("--show-sdks", "Show the available SDKs") do 
+    Xcode::Platforms.supported.each do |p|
+      puts "#{p.name}: #{p.platform}, #{p.version}"
+    end
+  end
+
+	opts.separator ""
+  opts.separator "Buildspec options:"
+
+  opts.on("-r", "--run [task]", "Run the Buildspec with the given task, defaults to 'deploy'") do |task|
+  	Xcode::Buildspec.parse
+  	task = 'deploy' if task.nil?
+  	Rake::Task[task].invoke
+  end
+
+  opts.on("-T", "--tasks", "List the available Buildspec tasks") do
+  	Xcode::Buildspec.parse
+  	puts Rake.application.tasks
+	end
+
+	opts.separator ""
+  opts.separator "Common options:"
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on_tail("-l", "--loglevel LEVEL", "Show only output at LEVEL or below " + Xcode::TerminalOutput::LEVELS.join(", ")) do |level|
+  	Xcode::TerminalOutput.log_level = level.to_sym
+  end
+
+  # opts.on_tail("-vv", "Show VERY verbose (debug level) output") do
+  # 	Xcode::TerminalOutput.log_level = :debug
+  # end
+
+  opts.on_tail("-q", "Hide all output except errors (equivilent to -l :error") do
+  	Xcode::TerminalOutput.log_level = :error
+  end
+
+  opts.on_tail("--version", "Show version") do
+    puts "Xcoder #{Xcode::VERSION}"
+    exit
+  end
+end.parse!

data/lib/xcode/builder.rb

@@ -1,7 +1,6 @@
-require 'xcode/shell'
 require 'xcode/provisioning_profile'
 require 'xcode/test/parsers/ocunit_parser.rb'
-require 'xcode/deploy/testflight'
+require 'xcode/test/parsers/kif_parser.rb'
 require 'xcode/builder/base_builder.rb'
 require 'xcode/builder/project_target_config_builder.rb'
 require 'xcode/builder/scheme_builder.rb'

data/lib/xcode/builder/base_builder.rb

@@ -1,83 +1,216 @@
+require 'xcode/builder/build_parser'
+
 module Xcode
   module Builder
     #
-    # This class tries to pull various bits of Xcoder together to provide a higher-level API for common 
+    # This class tries to pull various bits of Xcoder together to provide a higher-level API for common
     # project build tasks.
     #
     class BaseBuilder
+      include Xcode::TerminalOutput
+
       attr_accessor :profile, :identity, :build_path, :keychain, :sdk, :objroot, :symroot
       attr_reader   :config, :target
 
       def initialize(target, config)
         @target = target
         @config = config
-        
+
         @sdk = @target.project.sdk
-        @build_path = "#{File.dirname(@target.project.path)}/build/"
-        @objroot = @build_path
-        @symroot = @build_path
       end
-      
-      def common_environment
-        env = {}
-        env["OBJROOT"]  = "\"#{@objroot}\""
-        env["SYMROOT"]  = "\"#{@symroot}\""
-        env
+
+      def profile= (value)
+          if value.is_a?(ProvisioningProfile)
+            @profile = value
+          else
+            @profile = ProvisioningProfile.new(value)
+          end
+      end
+        
+      def cocoapods_installed?
+        system("which pod > /dev/null 2>&1")
+      end
+
+      def has_dependencies?
+        podfile = File.join(File.dirname(@target.project.path), "Podfile")
+        File.exists? podfile
+      end
+
+      #
+      # If a Podfile exists, perform a pod install
+      #
+      def dependencies
+        if has_dependencies? and cocoapods_installed?
+          print_task :builder, "Fetch depencies", :notice
+          podfile = File.join(File.dirname(@target.project.path), "Podfile")
+   
+          print_task :cocoapods, "pod setup", :info
+          with_command('pod setup').execute
+
+          print_task :cocoapods, "pod install", :info
+          with_command('pod install').execute
+        end
       end
+
+      def prepare_xcodebuild sdk=@sdk #:yield: Xcode::Shell::Command
+        with_command 'xcodebuild' do |cmd|
+
+          cmd.log_to_file = true
+          cmd.attach Xcode::Builder::XcodebuildParser.new
+          
+          cmd.env["OBJROOT"]  = "\"#{objroot}/\""
+          cmd.env["SYMROOT"]  = "\"#{symroot}/\""
+            
+          unless profile.nil?
+            profile.install
+            print_task "builder", "Using profile #{profile.install_path}", :debug
+            cmd.env["PROVISIONING_PROFILE"]   = "#{profile.uuid}"
+          end
+
+          unless @keychain.nil?
+            print_task 'builder', "Using keychain #{@keychain.path}", :debug
+            cmd.env["OTHER_CODE_SIGN_FLAGS"]  = "'--keychain #{@keychain.path}'"
+          end
+
+          unless @identity.nil?
+            print_task 'builder', "Using identity #{@identity}", :debug
+            cmd.env["CODE_SIGN_IDENTITY"]     = "\"#{@identity}\""
+          end
+
+          cmd << "-sdk #{sdk}" unless sdk.nil?
+
+          yield cmd if block_given?
+        end
+      end      
       
-      def build_environment
-        profile = install_profile        
-        env = common_environment
-        env["OTHER_CODE_SIGN_FLAGS"]  = "'--keychain #{@keychain.path}'" unless @keychain.nil?
-        env["CODE_SIGN_IDENTITY"]     = "\"#{@identity}\"" unless @identity.nil?
-        env["PROVISIONING_PROFILE"]   = "#{profile.uuid}" unless profile.nil?
-        env
+      def with_command command_line
+        cmd = Xcode::Shell::Command.new command_line
+        cmd.output_dir = objroot
+        yield cmd if block_given?
+        cmd
+      end
+
+      def prepare_build_command sdk=@sdk
+        cmd = prepare_xcodebuild sdk
+        cmd
+      end
+
+      def prepare_test_command sdk=@sdk
+        cmd = prepare_xcodebuild sdk
+        cmd.env["OBJROOT"]  = "\"#{objroot}/\""
+        cmd.env["SYMROOT"]  = "\"#{symroot}/\""
+        cmd.env["TEST_AFTER_BUILD"]="YES"
+        cmd.env["ONLY_ACTIVE_ARCH"]="NO"
+        # cmd.env["TEST_HOST"]=0
+        # cmd << "-sdk #{sdk}" unless sdk.nil?
+        cmd
       end
 
+      def prepare_clean_command sdk=@sdk
+        cmd = prepare_xcodebuild sdk
+        cmd << "clean"
+        cmd
+      end
 
-      def build(options = {:sdk => @sdk})    
-        cmd = xcodebuild
-        cmd << "-sdk #{options[:sdk]}" unless options[:sdk].nil?
+      def prepare_package_command
+        #package IPA
+        with_command 'xcrun' do |cmd|
+          cmd << "-sdk #{@sdk}" unless @sdk.nil?
+          cmd << "PackageApplication"
+          cmd << "-v \"#{app_path}\""
+          cmd << "-o \"#{ipa_path}\""
+
+          unless @profile.nil?
+            cmd << "--embed \"#{@profile}\""
+          end
+        end
+      end
+
+      def prepare_dsym_command
+        # package dSYM
+        with_command 'zip' do |cmd|
+          cmd << "-r"
+          cmd << "-T"
+          cmd << "-y \"#{dsym_zip_path}\""
+          cmd << "\"#{dsym_path}\""
+        end
+      end
+
+      #
+      # Build the project
+      #
+      def build options = {}, &block
+        print_task :builder, "Building #{product_name}", :notice
+        cmd = prepare_build_command options[:sdk]||@sdk
 
         with_keychain do
           cmd.execute
         end
+
         self
       end
 
-      # 
+      #
       # Invoke the configuration's test target and parse the resulting output
       #
       # If a block is provided, the report is yielded for configuration before the test is run
       #
-      def test(options = {:sdk => 'iphonesimulator'}) #, :parser => :OCUnit })
-        cmd = xcodebuild
-        cmd << "-sdk #{options[:sdk]}" unless options[:sdk].nil?
-        cmd.env["TEST_AFTER_BUILD"]="YES"
-
+      # TODO: Move implementation to the Xcode::Test module
+      def test options = {:sdk => 'iphonesimulator', :show_output => false}
         report = Xcode::Test::Report.new
+        print_task :builder, "Testing #{product_name}", :notice
+
+        cmd = prepare_test_command options[:sdk]||@sdk
+
         if block_given?
           yield(report)
         else
-          report.add_formatter :stdout
+          report.add_formatter :stdout, { :color_output => true }
           report.add_formatter :junit, 'test-reports'
         end
 
-        parser = Xcode::Test::Parsers::OCUnitParser.new report
+        cmd.attach Xcode::Test::Parsers::OCUnitParser.new(report)
+        cmd.show_output = options[:show_output] # override it if user wants output
 
         begin
-          cmd.execute(false) do |line|
-            parser << line
-          end
+          cmd.execute
         rescue Xcode::Shell::ExecutionError => e
-          puts "Test platform exited: #{e.message}"
-        ensure
-          parser.flush
+          # FIXME: Perhaps we should always raise this?
+          raise e if report.suites.count==0
         end
 
         report
       end
 
+      #
+      # Deploy the package through the chosen method
+      #
+      # @param method the deployment method (web, ssh, testflight)
+      # @param options options specific for the chosen deployment method
+      #
+      # If a block is given, the deployer is yielded before deploy() is called
+      #
+      # TODO: move deployment to Xcode::Deploy module
+      def deploy method, options = {}
+        print_task :builder, "Deploy to #{method}", :notice
+        options = {
+          :ipa_path => ipa_path,
+          :dsym_zip_path => dsym_zip_path,
+          :ipa_name => ipa_name,
+          :app_path => app_path,
+          :configuration_build_path => configuration_build_path,
+          :product_name => @config.product_name,
+          :info_plist => @config.info_plist
+        }.merge options
+
+        require "xcode/deploy/#{method.to_s}.rb"
+        deployer = Xcode::Deploy.const_get("#{method.to_s.capitalize}").new(self, options)
+
+        yield(deployer) if block_given?
+
+        deployer.deploy
+      end
+
       #
       # Upload to testflight
       #
@@ -86,70 +219,49 @@ module Xcode
       # @param api_token the API token for your testflight account
       # @param team_token the token for the team you want to deploy to
       #
-      def testflight(api_token, team_token)
-        raise "Can't find #{ipa_path}, do you need to call builder.package?" unless File.exists? ipa_path
-        raise "Can't find #{dsym_zip_path}, do you need to call builder.package?" unless File.exists? dsym_zip_path
+      # DEPRECATED, use deploy() instead
+      # def testflight(api_token, team_token)
+      #   raise "Can't find #{ipa_path}, do you need to call builder.package?" unless File.exists? ipa_path
+      #   raise "Can't find #{dsym_zip_path}, do you need to call builder.package?" unless File.exists? dsym_zip_path
 
-        testflight = Xcode::Deploy::Testflight.new(api_token, team_token)
-        yield(testflight) if block_given?
-        testflight.upload(ipa_path, dsym_zip_path)
-      end
+      #   testflight = Xcode::Deploy::Testflight.new(api_token, team_token)
+      #   yield(testflight) if block_given?
+      #   testflight.upload(ipa_path, dsym_zip_path)
+      # end
 
-      def clean
-        cmd = xcodebuild 
-        cmd << "-sdk #{@sdk}" unless @sdk.nil?          
-        cmd << "clean"
-        cmd.execute
+      def clean options = {:sdk=>@sdk}, &block
+        print_task :builder, "Cleaning #{product_name}", :notice
+        prepare_clean_command(options[:sdk]).execute
 
         @built = false
         @packaged = false
-        self
-      end    
-
-      def sign
-        cmd = Xcode::Shell::Command.new 'codesign'
-        cmd << "--force"
-        cmd << "--sign \"#{@identity}\""
-        cmd << "--resource-rules=\"#{app_path}/ResourceRules.plist\""
-        cmd << "--entitlements \"#{entitlements_path}\""
-        cmd << "\"#{ipa_path}\""
-        cmd.execute
-        
-        
         self
       end
 
-      def package
-        raise "Can't find #{app_path}, do you need to call builder.build?" unless File.exists? app_path
+      def package options = {}, &block
+        options = {:show_output => false}.merge(options)
 
-        #package IPA
-        cmd = Xcode::Shell::Command.new 'xcrun'     
-        cmd << "-sdk #{@sdk}" unless @sdk.nil?
-        cmd << "PackageApplication"
-        cmd << "-v \"#{app_path}\""
-        cmd << "-o \"#{ipa_path}\""
-    
-        unless @profile.nil?
-          cmd << "--embed \"#{@profile}\""
-        end
+        raise "Can't find #{app_path}, do you need to call builder.build?" unless File.exists? app_path or File.symlink? app_path
+
+        print_task 'builder', "Packaging #{product_name}", :notice
 
+        print_task :package, "generating IPA: #{ipa_path}", :info
         with_keychain do
-          cmd.execute
+          prepare_package_command.execute
         end
 
-        # package dSYM
-        cmd = Xcode::Shell::Command.new 'zip' 
-        cmd << "-r"
-        cmd << "-T"
-        cmd << "-y \"#{dsym_zip_path}\""
-        cmd << "\"#{dsym_path}\""
-        cmd.execute
+        print_task :package, "creating dSYM zip: #{dsym_zip_path}", :info
+        prepare_dsym_command.execute
 
         self
       end
 
+      def project_root
+        @target.project.path
+      end
+
       def configuration_build_path
-        "#{build_path}/#{@config.name}-#{@sdk}"
+        "#{symroot}/#{@config.name}-#{@sdk}"
       end
 
       def entitlements_path
@@ -166,6 +278,10 @@ module Xcode
         "#{configuration_build_path}/#{@config.product_name}-#{@config.name}-#{version}"
       end
 
+      def product_name
+        @config.product_name
+      end
+
       def ipa_path
         "#{product_version_basename}.ipa"
       end
@@ -178,35 +294,48 @@ module Xcode
         "#{product_version_basename}.dSYM.zip"
       end
 
-      private 
+      def ipa_name
+        File.basename(ipa_path)
+      end
 
-      def with_keychain(&block)
-        if @keychain.nil?
-          yield
-        else
-          Xcode::Keychains.with_keychain_in_search_path @keychain, &block
-        end
+      def bundle_identifier
+        @config.info_plist.identifier
       end
 
-      def install_profile
-        return nil if @profile.nil?
-        # TODO: remove other profiles for the same app?
-        p = ProvisioningProfile.new(@profile)
+      def bundle_version
+        @config.info_plist.version
+      end
 
-        ProvisioningProfile.installed_profiles.each do |installed|
-          if installed.identifiers==p.identifiers and installed.uuid==p.uuid
-            installed.uninstall
-          end
-        end
+      def objroot
+        @objroot ||= build_path
+      end
 
-        p.install
-        p
+      def symroot                
+        @symroot ||= File.join(build_path, 'Products')
       end
 
-      def xcodebuild #:yield: Xcode::Shell::Command
-        Xcode::Shell::Command.new 'xcodebuild', build_environment
+      def build_path=(path)
+        @build_path ||= path
+        FileUtils.mkdir_p @build_path
+      end
+
+      def build_path
+        return @build_path unless @build_path.nil?
+        @build_path = File.join File.dirname(@target.project.path), "Build"
+        FileUtils.mkdir_p @build_path
+        @build_path
+      end
+
+      private
+
+      def with_keychain(&block)
+        if @keychain.nil?
+          yield
+        else
+          Xcode::Keychains.with_keychain_in_search_path @keychain, &block
+        end
       end
 
     end
   end
-end
+end