xcodebuild-rb 0.1.0

data/lib/xcode_build/reporting/build_reporting.rb

@@ -0,0 +1,61 @@
+require 'ostruct'
+
+module XcodeBuild
+  module Reporting
+    module BuildReporting
+      def self.included(klass)
+        klass.instance_eval do
+          attr_reader :build
+        end
+      end
+      
+      def build_started(params)
+        @build = Build.new(params)
+        notify :build_started, @build
+      end
+
+      def build_step(params)
+        if @build.last_step
+          notify :build_step_finished, @build.last_step
+        end
+
+        @build.add_step(params)
+
+        notify :build_step_started, @build.last_step
+      end
+
+      def build_error_detected(params)
+        @build.last_step.add_error(params)
+      end
+
+      def build_succeeded
+        @build.success!
+        build_finished
+      end
+
+      def build_failed
+        @build.failure!
+        build_finished
+      end
+
+      def build_step_failed(params)
+        if step = @build.step_with_params(params)
+          step.failed = true
+        end
+      end
+      
+      private
+
+      def build_finished
+        if @build.last_step
+          notify :build_step_finished, @build.last_step
+        end
+
+        notify :build_finished, @build
+      end
+      
+      class Build < BuildAction
+      end
+    end
+  end
+end

data/lib/xcode_build/reporting/clean_reporting.rb

@@ -0,0 +1,59 @@
+module XcodeBuild
+  module Reporting
+    module CleanReporting
+      def self.included(klass)
+        klass.instance_eval do
+          attr_reader :clean
+        end
+      end
+      
+      def clean_started(params)
+        @clean = Clean.new(params)
+        notify :clean_started, @clean
+      end
+      
+      def clean_step(params)
+        if clean.last_step
+          notify :clean_step_finished, clean.last_step
+        end
+
+        clean.add_step(params)
+
+        notify :clean_step_started, clean.last_step
+      end
+      
+      def clean_error_detected(params)
+        clean.last_step.add_error(params)
+      end
+      
+      def clean_succeeded
+        clean.success!
+        clean_finished
+      end
+      
+      def clean_failed
+        clean.failure!
+        clean_finished
+      end
+      
+      def clean_step_failed(params)
+        if step = clean.step_with_params(params)
+          step.failed = true
+        end
+      end
+      
+      private
+      
+      def clean_finished
+        if clean.last_step
+          notify :clean_step_finished, clean.last_step
+        end
+        
+        notify :clean_finished, clean
+      end
+      
+      class Clean < BuildAction
+      end
+    end
+  end
+end

data/lib/xcode_build/tasks/build_task.rb

@@ -0,0 +1,84 @@
+require 'rake/tasklib'
+
+module XcodeBuild
+  module Tasks
+    class BuildTask < ::Rake::TaskLib
+      attr_accessor :project_name
+      attr_accessor :target
+      attr_accessor :workspace
+      attr_accessor :scheme
+      attr_accessor :configuration
+      attr_accessor :arch
+      attr_accessor :sdk
+      attr_accessor :xcconfig
+      attr_accessor :output_to
+      attr_accessor :formatter
+      attr_accessor :invoke_from_within
+      attr_accessor :reporter
+
+      def initialize(namespace = :xcode, &block)
+        @namespace = namespace
+        @output_to = STDOUT
+        @invoke_from_within = "."
+        
+        yield self if block_given?
+        define
+      end
+
+      def run(task)
+        Rake::Task["#{@namespace}:#{task}"].invoke
+      end
+
+      def build_opts
+        [].tap do |opts|
+          opts << "-project #{project_name}" if project_name
+          opts << "-target #{target}" if target
+          opts << "-workspace #{workspace}" if workspace
+          opts << "-scheme #{scheme}" if scheme
+          opts << "-configuration #{configuration}" if configuration
+          opts << "-arch #{arch}" if arch
+          opts << "-sdk #{sdk}" if sdk
+          opts << "-xcconfig #{xcconfig}" if xcconfig
+        end
+      end
+
+      private
+      
+      def output_buffer
+        if reporter
+          XcodeBuild::OutputTranslator.new(reporter)
+        elsif formatter
+          default_reporter = XcodeBuild::Reporter.new(formatter)
+          XcodeBuild::OutputTranslator.new(default_reporter)
+        else
+          output_to
+        end
+      end
+      
+      def build_opts_string(*additional_opts)
+        (build_opts + additional_opts).join(" ")
+      end
+
+      def define
+        namespace(@namespace) do
+          desc "Builds the specified target(s)."
+          task :build do
+            Dir.chdir(invoke_from_within) do
+              XcodeBuild.run(build_opts_string, output_buffer)
+            end
+          end
+          
+          desc "Cleans the build using the same build settings."
+          task :clean do
+            Dir.chdir(invoke_from_within) do
+              XcodeBuild.run(build_opts_string("clean"), output_buffer)
+            end
+          end
+          
+          desc "Builds the specified target(s) from a clean slate."
+          task :cleanbuild => [:clean, :build]
+        end
+      end
+    end
+  end
+end

data/lib/xcode_build/translations.rb

@@ -0,0 +1,20 @@
+module XcodeBuild
+  module Translations
+    extend self
+    
+    def registered_translations
+      @registered_translators ||= {}
+    end
+    
+    def register_translation(key, the_module)
+      registered_translations[key] = the_module
+    end
+    
+    def registered_translation(key)
+      registered_translations[key]
+    end
+  end
+end
+
+require_relative "translations/building"
+require_relative "translations/cleaning"

data/lib/xcode_build/translations/building.rb

@@ -0,0 +1,101 @@
+module XcodeBuild
+  module Translations
+    module Building
+      def attempt_to_translate(line)
+        if line =~ /^\=\=\= BUILD/
+          notify_build_started(line)
+        end
+        
+        return unless building?
+        
+        if line =~ /^\*\* BUILD (\w+) \*\*/
+          notify_build_ended($1)
+          return
+        end
+
+        if @beginning_build_step
+          @beginning_build_step = false
+          notify_build_step(line) unless line.strip.empty?
+          return
+        end
+
+        if @beginning_error_report
+          if line =~ /^\(\d+ failure(s?)\)/
+            @beginning_error_report = false
+          else
+            notify_build_step_failed(line)
+          end
+        end
+
+        case line
+        when /^(.*):(\d+):(\d+): error: (.*)$/
+          notify_build_error($1, $2, $3, $4)
+        when /^The following build commands failed:/
+          @beginning_error_report = true
+        when /^\n/
+          @beginning_build_step = true
+        end
+      end
+      
+      def building?
+        @building
+      end
+
+      private
+
+      def notify_build_started(line)
+        @building = true
+        
+        target = line.match(/TARGET (\w+)/)[1]
+        project = line.match(/PROJECT (\w+)/)[1]
+
+        if line =~ /DEFAULT CONFIGURATION \((\w+)\)/
+          configuration = $1
+          default = true
+        else
+          configuration = line.match(/CONFIGURATION (\w+)/)[1]
+          default = false
+        end
+
+        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)])
+      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
+        }])
+      end
+
+      def notify_build_ended(result)
+        if result =~ /SUCCEEDED/
+          notify_delegate(:build_succeeded, required: true)
+        else
+          notify_delegate(:build_failed, required: true)
+        end
+      end
+
+      def notify_build_step_failed(line)
+        notify_delegate(:build_step_failed, args: [build_step_from_line(line)])
+      end
+
+      def build_step_from_line(line)
+        parts = line.strip.split(" ")
+        {type: parts.shift, arguments: parts}
+      end
+    end
+
+    register_translation :building, Building
+  end
+end

data/lib/xcode_build/translations/cleaning.rb

@@ -0,0 +1,96 @@
+module XcodeBuild
+  module Translations
+    module Cleaning
+      def attempt_to_translate(line)
+        if line =~ /^\=\=\= CLEAN/
+          notify_clean_started(line)
+        end
+        
+        return unless cleaning?
+        
+        if line =~ /^\*\* CLEAN (\w+) \*\*/
+          notify_clean_ended($1)
+          return
+        end
+        
+        if @beginning_clean_step
+          @beginning_clean_step = false
+          notify_clean_step(line) unless line.strip.empty?
+          return
+        end
+        
+        if @beginning_error_report
+          if line =~ /^\(\d+ failure(s?)\)/
+            @beginning_error_report = false
+          else
+            notify_clean_step_failed(line)
+          end
+        end
+        
+        case line
+        when /^error: (.*)$/
+          notify_clean_error($1)
+        when /^The following build commands failed:/
+          @beginning_error_report = true
+        when /^\n/
+          @beginning_clean_step = true
+        end
+      end
+
+      private
+      
+      def cleaning?
+        @cleaning
+      end
+      
+      def notify_clean_started(line)
+        @cleaning = true
+        
+        target = line.match(/TARGET (\w+)/)[1]
+        project = line.match(/PROJECT (\w+)/)[1]
+
+        if line =~ /DEFAULT CONFIGURATION \((\w+)\)/
+          configuration = $1
+          default = true
+        else
+          configuration = line.match(/CONFIGURATION (\w+)/)[1]
+          default = false
+        end
+
+        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)])
+      end
+      
+      def notify_clean_step_failed(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}])
+      end
+      
+      def notify_clean_ended(result)
+        if result =~ /SUCCEEDED/
+          notify_delegate(:clean_succeeded, required: true)
+        else
+          notify_delegate(:clean_failed, required: true)
+        end
+      end
+      
+      def clean_step_from_line(line)
+        parts = line.strip.split(" ")
+        {type: parts.shift, arguments: parts}
+      end
+    end
+
+    register_translation :cleaning, Cleaning
+  end
+end

data/lib/xcode_build/utilities/colorize.rb

@@ -0,0 +1,45 @@
+module XcodeBuild
+  module Utilities
+    module Colorize # borrowed from rspec-core
+      def color(text, color_code)
+        color_enabled? ? "#{color_code}#{text}\e[0m" : text
+      end
+
+      def bold(text)
+        color(text, "\e[1m")
+      end
+
+      def red(text)
+        color(text, "\e[31m")
+      end
+
+      def green(text)
+        color(text, "\e[32m")
+      end
+
+      def yellow(text)
+        color(text, "\e[33m")
+      end
+
+      def blue(text)
+        color(text, "\e[34m")
+      end
+
+      def magenta(text)
+        color(text, "\e[35m")
+      end
+
+      def cyan(text)
+        color(text, "\e[36m")
+      end
+
+      def white(text)
+        color(text, "\e[37m")
+      end
+
+      def short_padding
+        '  '
+      end
+    end
+  end
+end