xcodebuild-rb 0.1.0 → 0.2.0

data/lib/xcode_build/translations.rb

@@ -16,5 +16,5 @@ module XcodeBuild
   end
 end
 
-require_relative "translations/building"
-require_relative "translations/cleaning"
+require "xcode_build/translations/building"
+require "xcode_build/translations/cleaning"

data/lib/xcode_build/translations/building.rb

@@ -8,8 +8,8 @@ module XcodeBuild
         
         return unless building?
         
-        if line =~ /^\*\* BUILD (\w+) \*\*/
-          notify_build_ended($1)
+        if line =~ /^\*\* (BUILD|ARCHIVE) (\w+) \*\*/
+          notify_build_ended($1, $2)
           return
         end
 
@@ -30,6 +30,10 @@ module XcodeBuild
         case line
         when /^(.*):(\d+):(\d+): error: (.*)$/
           notify_build_error($1, $2, $3, $4)
+        when /^\s+setenv (\w+) (.*)/
+          notify_env_var($1, $2)
+        when /^Command (.*) failed with exit code (\d+)/
+          notify_build_step_command_failed($1, $2)
         when /^The following build commands failed:/
           @beginning_error_report = true
         when /^\n/
@@ -57,42 +61,50 @@ module XcodeBuild
           default = false
         end
 
-        notify_delegate(:build_started, required: true, args: [{
-                 target: target,
-                project: project,
-          configuration: configuration,
-                default: default
+        notify_delegate(:build_started, :required => true, :args => [{
+                 :target => target,
+                :project => project,
+          :configuration => configuration,
+                :default => default
         }])
       end
 
       def notify_build_step(line)
-        notify_delegate(:build_step, args: [build_step_from_line(line)])
+        notify_delegate(:build_step, :args => [build_step_from_line(line)])
       end
 
       def notify_build_error(file, line, char, message)
-        notify_delegate(:build_error_detected, args: [{
-             file: file,
-             line: line.to_i,
-             char: char.to_i,
-          message: message
+        notify_delegate(:build_error_detected, :args => [{
+             :file => file,
+             :line => line.to_i,
+             :char => char.to_i,
+          :message => message
         }])
       end
+      
+      def notify_build_step_command_failed(command, exit_code)
+        notify_delegate(:build_error_detected, :args => [{:command => command, :exit_code => exit_code.to_i}])
+      end
 
-      def notify_build_ended(result)
+      def notify_build_ended(archive_or_build, result)
         if result =~ /SUCCEEDED/
-          notify_delegate(:build_succeeded, required: true)
+          notify_delegate(:build_succeeded, :args => [archive_or_build], :required => true)
         else
-          notify_delegate(:build_failed, required: true)
+          notify_delegate(:build_failed, :args => [archive_or_build], :required => true)
         end
       end
 
       def notify_build_step_failed(line)
-        notify_delegate(:build_step_failed, args: [build_step_from_line(line)])
+        notify_delegate(:build_step_failed, :args => [build_step_from_line(line)])
+      end
+      
+      def notify_env_var(key, value)
+        notify_delegate(:build_env_variable_detected, :args => [key, value])
       end
 
       def build_step_from_line(line)
         parts = line.strip.split(" ")
-        {type: parts.shift, arguments: parts}
+        {:type => parts.shift, :arguments => parts}
       end
     end
 

data/lib/xcode_build/translations/cleaning.rb

@@ -57,37 +57,37 @@ module XcodeBuild
           default = false
         end
 
-        notify_delegate(:clean_started, required: true, args: [{
-                 target: target,
-                project: project,
-          configuration: configuration,
-                default: default
+        notify_delegate(:clean_started, :required => true, :args => [{
+                 :target => target,
+                :project => project,
+          :configuration => configuration,
+                :default => default
         }])
       end
       
       def notify_clean_step(line)
-        notify_delegate(:clean_step, args: [clean_step_from_line(line)])
+        notify_delegate(:clean_step, :args => [clean_step_from_line(line)])
       end
       
       def notify_clean_step_failed(line)
-        notify_delegate(:clean_step_failed, args: [clean_step_from_line(line)])
+        notify_delegate(:clean_step_failed, :args => [clean_step_from_line(line)])
       end
       
       def notify_clean_error(message)
-        notify_delegate(:clean_error_detected, args: [{message: message}])
+        notify_delegate(:clean_error_detected, :args => [{:message => message}])
       end
       
       def notify_clean_ended(result)
         if result =~ /SUCCEEDED/
-          notify_delegate(:clean_succeeded, required: true)
+          notify_delegate(:clean_succeeded, :required => true)
         else
-          notify_delegate(:clean_failed, required: true)
+          notify_delegate(:clean_failed, :required => true)
         end
       end
       
       def clean_step_from_line(line)
         parts = line.strip.split(" ")
-        {type: parts.shift, arguments: parts}
+        {:type => parts.shift, :arguments => parts}
       end
     end
 

data/lib/xcodebuild.rb

@@ -1 +1 @@
-require_relative 'xcode_build'
+require 'xcode_build'

data/spec/build_task_spec.rb

@@ -13,12 +13,17 @@ describe XcodeBuild::Tasks::BuildTask do
     XcodeBuild::Tasks::BuildTask.new(:test)
     Rake::Task["test:build"].should be_instance_of(Rake::Task)
   end
-  
+
+  it "defines an archive task" do
+    XcodeBuild::Tasks::BuildTask.new
+    Rake::Task["xcode:archive"].should be_instance_of(Rake::Task)
+  end
+
   it "defines a clean task" do
     XcodeBuild::Tasks::BuildTask.new
     Rake::Task["xcode:clean"].should be_instance_of(Rake::Task)
   end
-  
+
   it "defines a cleanbuild" do
     XcodeBuild::Tasks::BuildTask.new
     Rake::Task["xcode:cleanbuild"].should be_instance_of(Rake::Task)
@@ -68,71 +73,174 @@ describe XcodeBuild::Tasks::BuildTask do
     end
   end
 
-  context "build task" do
-    it "runs xcodebuild with the configured build_opts" do
-      task = XcodeBuild::Tasks::BuildTask.new do |task|
-        task.project_name = "TestProject.xcproject"
-        task.configuration = "Debug"
-      end
-
-      XcodeBuild.should_receive(:run).with(task.build_opts.join(" "), anything())
-      task.run(:build)
-    end
-    
-    it "defaults to outputting the raw output to STDOUT" do
-      task = XcodeBuild::Tasks::BuildTask.new
-      XcodeBuild.should_receive(:run).with(anything(), STDOUT)
-      task.run(:build)
+  shared_examples_for "any task" do
+    it "directs xcodebuild output into the translator" do
+      task = XcodeBuild::Tasks::BuildTask.new { |t| t.scheme = 'TestScheme' }
+      XcodeBuild.should_receive(:run).with(anything, instance_of(XcodeBuild::OutputTranslator)).and_return(0)
+      task.run(task_name)
     end
-    
-    it "uses a custom output buffer if specified" do
+
+    it "uses a custom output buffer if specified and a formatter has not been set" do
       buffer = stub('output buffer')
       task = XcodeBuild::Tasks::BuildTask.new do |t|
+        t.formatter = nil
         t.output_to = buffer
+        t.scheme = 'TestScheme'
       end
-      XcodeBuild.should_receive(:run).with(anything(), buffer)
-      task.run(:build)
+      task.reporter.should_receive(:direct_raw_output_to=).with(buffer)
+      XcodeBuild.stub(:run).with(anything, anything).and_return(0)
+      task.run(task_name)
     end
-    
-    it "outputs the translator delegating to the reporter if formatter is set" do
-      formatter = stub('formatter')
+
+    it "ignores the value of output_to if a formatter has been set" do
       task = XcodeBuild::Tasks::BuildTask.new do |t|
-        t.formatter = formatter
+        t.formatter = stub('formatter')
+        t.output_to = stub('output buffer')
+        t.scheme = 'TestScheme'
       end
-      XcodeBuild.should_receive(:run).with(anything(),
-        output_translator_delegating_to(instance_of(XcodeBuild::Reporter)))
-      task.run(:build)
+      task.reporter.should_not_receive(:direct_raw_output_to=).with(anything)
+      XcodeBuild.stub(:run).with(anything, anything).and_return(0)
+      task.run(task_name)
     end
-    
+
+    it "raises if xcodebuild returns a non-zero exit code" do
+      task = XcodeBuild::Tasks::BuildTask.new { |t| t.scheme = 'TestScheme' }
+      XcodeBuild.stub(:run).with(anything, anything).and_return(99)
+      lambda { task.run(task_name) }.should raise_error
+    end
+
     it "changes directory if invoke_from_within is set" do
       task = XcodeBuild::Tasks::BuildTask.new do |task|
         task.invoke_from_within = "foo/bar"
+        task.scheme = 'TestScheme'
       end
-      
+
       Dir.should_receive(:chdir).with("foo/bar").and_yield
-      XcodeBuild.should_receive(:run)
-      task.run(:build)
+      XcodeBuild.should_receive(:run).and_return(0)
+      task.run(task_name)
     end
   end
-  
+
+  shared_examples_for "build task" do
+    it "runs xcodebuild with the configured build_opts" do
+      @task = XcodeBuild::Tasks::BuildTask.new do |task|
+        task.project_name = "TestProject.xcproject"
+        task.configuration = "Debug"
+        task.scheme = 'TestScheme'
+      end
+
+      XcodeBuild.should_receive(:run).with(build_opts.join(" "), anything).and_return(0)
+      @task.run(task_name)
+    end
+
+    it "calls the after_build block after running successfully, passing in the build object from the report" do
+      received_build = nil
+
+      @task = XcodeBuild::Tasks::BuildTask.new do |task|
+        task.scheme = 'TestProject'
+        task.after_build do |build|
+          received_build = build
+        end
+      end
+
+      @task.reporter.stub(:build).and_return(expected_build = stub('build', :failed? => false))
+      XcodeBuild.stub(:run).with(anything, anything).and_return(0)
+
+      @task.run(task_name)
+
+      received_build.should == expected_build
+    end
+
+    it "raises if the build has failed, even though xcodebuild returned a zero exit code" do
+      @task = XcodeBuild::Tasks::BuildTask.new
+
+      @task.reporter.stub(:build).and_return(stub('build', :failed? => true))
+      XcodeBuild.stub(:run).with(anything, anything).and_return(0)
+
+      lambda { @task.run(task_name) }.should raise_error
+    end
+  end
+
+  context "build task" do
+    let(:task_name) { :build }
+    let(:build_opts) { @task.build_opts + ['build'] }
+
+    it_behaves_like "any task"
+    it_behaves_like "build task"
+  end
+
+  context "archive task" do
+    let(:task_name) { :archive }
+    let(:build_opts) { @task.build_opts + ['archive'] }
+
+    it_behaves_like "any task"
+    it_behaves_like "build task"
+
+    it "raises if no scheme is specified" do
+      task = XcodeBuild::Tasks::BuildTask.new
+      lambda { task.run(:archive) }.should raise_error
+    end
+    
+    it "calls the after_archive block after running successfully, passing in the build object from the report" do
+      received_build = nil
+
+      @task = XcodeBuild::Tasks::BuildTask.new do |task|
+        task.scheme = 'TestProject'
+        task.after_archive do |build|
+          received_build = build
+        end
+      end
+
+      @task.reporter.stub(:build).and_return(expected_build = stub('build', :failed? => false))
+      XcodeBuild.stub(:run).with(anything, anything).and_return(0)
+
+      @task.run(task_name)
+
+      received_build.should == expected_build
+    end
+  end
+
   context "clean task" do
+    let(:task_name) { :clean }
+
+    it_behaves_like "any task"
+
     it "runs xcodebuild with the 'clean' action" do
       task = XcodeBuild::Tasks::BuildTask.new
-      XcodeBuild.should_receive(:run).with("clean", anything())
+      XcodeBuild.should_receive(:run).with("clean", anything).and_return(0)
       task.run(:clean)
     end
+    
+    it "calls the after_clean block after running successfully, passing in the clean object from the report" do
+      received_clean = nil
+
+      @task = XcodeBuild::Tasks::BuildTask.new do |task|
+        task.scheme = 'TestProject'
+        task.after_clean do |clean|
+          received_clean = clean
+        end
+      end
+
+      @task.reporter.stub(:clean).and_return(expected_clean = stub('clean', :failed? => false))
+      XcodeBuild.stub(:run).with(anything, anything).and_return(0)
+
+      @task.run(task_name)
+
+      received_clean.should == expected_clean
+    end
   end
-  
+
   context "cleanbuild task" do
     it "runs the clean task and then the build task" do
       task = XcodeBuild::Tasks::BuildTask.new
-      XcodeBuild.should_receive(:run).with("clean", anything()) do
-        XcodeBuild.should_receive(:run).with("", anything())
-      end
+
+      XcodeBuild.should_receive(:run).with("clean", anything).ordered.and_return(0)
+      XcodeBuild.should_receive(:run).with("build", anything).ordered.and_return(0)
+
       task.run(:cleanbuild)
     end
   end
-  
+
   RSpec::Matchers.define :output_translator_delegating_to do |expected|
     match do |actual|
       actual.should be_instance_of(XcodeBuild::OutputTranslator)

data/spec/output_translator_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe XcodeBuild::OutputTranslator do
   let(:delegate)   { mock('delegate') }
-  let(:translator) { XcodeBuild::OutputTranslator.new(delegate, ignore_global_translations: true) }
+  let(:translator) { XcodeBuild::OutputTranslator.new(delegate, :ignore_global_translations => true) }
   
   it "notifies the delegate of each line received (to assist additional processing elsewhere)" do
     delegate.should_receive(:beginning_translation_of_line).with("the line")

data/spec/reporting/build_reporting_spec.rb

@@ -82,7 +82,7 @@ describe XcodeBuild::Reporting::BuildReporting do
            
       delegate.should_receive(:build_step_finished).with reporter.build.last_step
            
-      event({:build_succeeded=>{}})
+      event({:build_succeeded=>["BUILD"]})
     end
     
     it "notifies it's delegate when the last build step finishes and the build fails" do
@@ -96,19 +96,62 @@ describe XcodeBuild::Reporting::BuildReporting do
            
       delegate.should_receive(:build_step_finished).with reporter.build.last_step
            
-      event({:build_succeeded=>{}})
+      event({:build_succeeded=>["BUILD"]})
+    end
+    
+    it "associates build errors with the right build step" do
+      assume_build_started
+
+      event({:build_step=>
+        {:type=>"CompileC",
+         :arguments=>
+          ["build/ExampleProject.build/Release-iphoneos/ExampleProject.build/Objects-normal/armv7/main.o",
+           "ExampleProject/AppDelegate.m",
+           "normal",
+           "armv7",
+           "objective-c",
+           "com.apple.compilers.llvm.clang.1_0.compiler"]}})
+           
+      event({:build_error_detected=>
+        {:file=>
+          "/Users/luke/Code/mine/xcodebuild/resources/ExampleProject/ExampleProject/main.m",
+         :line=>16,
+         :char=>42,
+         :message=>"expected ';' after expression [1]"}})
+         
+      reporter.build.last_step.should have(1).errors
+    end
+    
+    it "associates build step command errors with the right build step" do
+      assume_build_started
+
+      event({:build_step=>
+        {:type=>"CompileC",
+         :arguments=>
+          ["build/ExampleProject.build/Release-iphoneos/ExampleProject.build/Objects-normal/armv7/main.o",
+           "ExampleProject/AppDelegate.m",
+           "normal",
+           "armv7",
+           "objective-c",
+           "com.apple.compilers.llvm.clang.1_0.compiler"]}})
+           
+      event({:build_error_detected=>
+        {:command => "/bin/sh",
+         :exit_code => 1}})
+         
+      reporter.build.last_step.should have(1).errors
     end
     
     it "notifies it's delegate that the build has finished when it is successful" do
       assume_build_started
       delegate.should_receive(:build_finished).with(reporter.build)
-      event({:build_succeeded=>{}})
+      event({:build_succeeded=>["BUILD"]})
     end
     
     it "notifies it's delegate that the build has finished when it fails" do
       assume_build_started
       delegate.should_receive(:build_finished).with(reporter.build)
-      event({:build_failed=>{}})
+      event({:build_failed=>["BUILD"]})
     end
     
     it "tracks the time a build takes" do
@@ -120,12 +163,18 @@ describe XcodeBuild::Reporting::BuildReporting do
            :default=>true}})
            
         Timecop.travel(Chronic.parse("5 seconds from now")) do
-          event({:build_succeeded=>{}})
+          event({:build_succeeded=>["BUILD"]})
         end
       end
       
       reporter.build.duration.should be_within(0.01).of(5)
     end
+    
+    it "tracks any environment variables reported by the build" do
+      assume_build_started
+      event({:build_env_variable_detected=>["TEST_AFTER_BUILD", "YES"]})
+      reporter.build.environment["TEST_AFTER_BUILD"].should == "YES"
+    end
   end
   
   context "once a build has started" do
@@ -176,7 +225,7 @@ describe XcodeBuild::Reporting::BuildReporting do
            "objective-c",
            "com.apple.compilers.llvm.clang.1_0.compiler"]}})
            
-      event({:build_succeeded=>{}})
+      event({:build_succeeded=>["BUILD"]})
     end
     
     it_behaves_like "any build"
@@ -233,7 +282,7 @@ describe XcodeBuild::Reporting::BuildReporting do
            "objective-c",
            "com.apple.compilers.llvm.clang.1_0.compiler"]}})
            
-      event({:build_failed=>{}})
+      event({:build_failed=>["BUILD"]})
       
       event({:build_step_failed=>
         {:type=>"CompileC",
@@ -289,7 +338,11 @@ describe XcodeBuild::Reporting::BuildReporting do
     params = event_data.values.first
     
     if params.any?
-      reporter.send(message, params)
+      if params.is_a?(Hash)
+        reporter.send(message, params)
+      else
+        reporter.send(message, *params)
+      end
     else
       reporter.send(message)
     end