xcoder 0.1.15 → 0.1.18

data/lib/xcode/info_plist.rb

@@ -34,6 +34,22 @@ module Xcode
       @plist['CFBundleVersion'] = version.to_s
     end
 
+    def identifier
+      @plist['CFBundleIdentifier']
+    end
+
+    def identifier=(identifier)
+      @plist['CFBundleIdentifier'] = identifier
+    end
+
+    def display_name
+      @plist['CFBundleDisplayName']
+    end
+
+    def display_name=(name)
+      @plist['CFBundleDisplayName'] = name
+    end
+
     def save
       File.open(@plist_location, 'w') {|f| f << @plist.to_plist}
     end

data/lib/xcode/keychain.rb

@@ -1,18 +1,12 @@
 module Xcode
   
   module Keychains
-    
+
     #
     # Yield when the keychain is in the search path and remove it when the block returns
     #
     def self.with_keychain_in_search_path(kc, &block)
-      keychains = self.search_path
-      begin 
-        self.search_path = [kc] + keychains
-        yield
-      ensure
-        self.search_path = keychains
-      end
+      kc.in_search_path &block
     end
     
     
@@ -45,6 +39,8 @@ module Xcode
   end
   
   class Keychain
+    include Xcode::TerminalOutput
+
     attr_accessor :name, :path
     
     TEMP_PASSWORD = "build_keychain_password"
@@ -61,6 +57,27 @@ module Xcode
       
       yield(self) if block_given?
     end
+
+    def to_s
+      "Keychain(#{@name})"
+    end
+
+    #
+    # Installs this keychain in the head of teh search path and restores the original on
+    # completion of the block
+    #
+    # @param the block to be invoked with the modified search path
+    #
+    def in_search_path(&block)
+      keychains = Keychains.search_path
+      begin 
+        Keychains.search_path = [self] + keychains
+        yield
+      ensure
+        Keychains.search_path = keychains
+        # print_task 'keychain', "Restored search path"
+      end
+    end
     
     #
     # Import the .p12 certificate file into the keychain using the provided password
@@ -88,8 +105,8 @@ module Xcode
       cmd << "find-certificate"
       cmd << "-a"
       cmd << "\"#{@path}\""
-      data = cmd.execute(false).join("")
-      data.scan /\s+"labl"<blob>="([^"]+)"/ do |m|
+      cmd.show_output = false
+      cmd.execute.join("").scan /\s+"labl"<blob>="([^"]+)"/ do |m|
         names << m[0]
       end
       names
@@ -132,6 +149,12 @@ module Xcode
       cmd << "\"#{path}\""
       cmd.execute
       
+      cmd = Xcode::Shell::Command.new "security"
+      cmd << "set-keychain-settings"
+      cmd << "-u"
+      cmd << "\"#{path}\""
+      cmd.execute
+      
       kc = Xcode::Keychain.new(path)
       yield(kc) if block_given?
       kc

data/lib/xcode/platform.rb

@@ -0,0 +1,65 @@
+module Xcode
+  
+  module Platforms
+    @@platforms = []
+        
+    def self.[] sdk_name
+      supported.find {|p| p.sdk==sdk_name}
+    end
+    
+    def self.find platform, version = nil
+      platform = supported.sort do
+        |a,b| a.version.to_f <=> b.version.to_f 
+      end.find do |p| 
+        p.platform==platform and (version.nil? or p.version==version)
+      end
+      
+      raise "Unable to find a platform #{platform},#{version} - available platforms are #{supported.map{|p| p.sdk}.join(', ')}" if platform.nil?
+      
+      platform
+    end
+
+    def self.supported
+      return @@platforms unless @@platforms.count==0
+      
+      parsing = false
+      `xcodebuild -showsdks`.split("\n").each do |l|
+        l.strip!
+        if l=~/(.*)\s+SDKs:/
+          parsing = true
+        elsif l=~/^\s*$/
+          parsing = false
+        elsif parsing
+          l=~/([^\t]+)\t+\-sdk (.*)/
+          name = $1.strip
+          $2.strip=~/([a-zA-Z]+)(\d+\.\d+)/
+
+          platform = Platform.new name, $1, $2          
+          @@platforms << platform
+        end
+      end
+      
+      @@platforms
+    end
+        
+  end
+  
+  class Platform
+    attr_reader :platform, :name, :version
+    
+    def initialize name, platform, version
+      @platform = platform
+      @name = name
+      @version = version
+    end
+        
+    def sdk
+      "#{@platform}#{@version}"
+    end
+    
+    def to_s
+      "#{name} #{sdk}"
+    end
+  end
+  
+end

data/lib/xcode/project.rb

@@ -294,7 +294,7 @@ module Xcode
 
       target.name = name
 
-      build_configuration_list = @registry.add_object(ConfigurationList.configration_list)
+      build_configuration_list = @registry.add_object(ConfigurationList.configuration_list)
       target.build_configuration_list = build_configuration_list.identifier
 
       target.project = self
@@ -341,8 +341,8 @@ module Xcode
       end
       schemes.each do |s|
         puts " + scheme #{s.name}"
-        puts "    + Launch action => target:#{s.launch.target.name}, config:#{s.launch.name}" unless s.launch.nil?
-        puts "    + Test action   => target:#{s.test.target.name}, config:#{s.test.name}" unless s.test.nil?
+        puts "    + targets: #{s.build_targets.map{|t| t.name}}"
+        puts "    + config:  #{s.build_config}"
       end
     end
 
@@ -367,5 +367,9 @@ module Xcode
       registry
     end
 
+    def to_s
+      "#{name} (Project)"
+    end
+
   end
 end

data/lib/xcode/provisioning_profile.rb

@@ -1,5 +1,6 @@
 module Xcode
   class ProvisioningProfile
+    include Xcode::TerminalOutput
     attr_reader :path, :name, :uuid, :identifiers, :devices, :appstore
     def initialize(path)
       
@@ -9,6 +10,7 @@ module Xcode
       @identifiers = []
       @devices = []
       @appstore = true
+      @enterprise = false
       
       # TODO: im sure this could be done in a nicer way.  maybe read out the XML-like stuff and use the plist -> json converter
       uuid = nil
@@ -19,6 +21,10 @@ module Xcode
           @appstore = false
         end
         
+        if input=~/<key>ProvisionsAllDevices<\/key>/
+          @enterprise = true
+        end
+        
         if input=~/<key>ProvisionedDevices<\/key>.*?<array>(.*?)<\/array>/im
           $1.split(/<string>/).each do |id|
             next if id.nil? or id.strip==""
@@ -44,6 +50,10 @@ module Xcode
     def appstore?
       @appstore
     end
+    
+    def enterprise?
+      @enterprise
+    end
 
     def self.profiles_path
       File.expand_path "~/Library/MobileDevice/Provisioning\\ Profiles/"  
@@ -54,11 +64,27 @@ module Xcode
     end
     
     def install
-      Xcode::Shell.execute("cp #{self.path} #{self.install_path}")   
+      # Do not reinstall if profile is same and is already installed
+      return if (self.path == self.install_path.gsub(/\\ /, ' '))
+      
+      ProvisioningProfile.installed_profiles.each do |installed|
+        if installed.identifiers==self.identifiers and installed.uuid==self.uuid
+          installed.uninstall
+        end
+      end
+
+      # print_task "profile", "installing #{self.path} with uuid #{self.uuid}", :info
+      cmd = Xcode::Shell::Command.new 'cp'
+      cmd << self.path
+      cmd << self.install_path
+      cmd.execute
     end
     
     def uninstall
-      Xcode::Shell.execute("rm -f #{self.install_path}")
+      # print_task "profile", "removing #{self.install_path}", :info
+      cmd = Xcode::Shell::Command.new 'rm'
+      cmd << "-f #{self.install_path}"
+      cmd.execute
     end
 
     def self.installed_profiles
@@ -66,6 +92,16 @@ module Xcode
         ProvisioningProfile.new(file)
       end
     end
+
+    def self.find_installed_by_uuid uuid
+      ProvisioningProfile.installed_profiles.each do |p|
+        return p if p.uuid == uuid
+      end
+    end
+
+    def self.installed_profile(name)
+      self.installed_profiles.select {|p| p.name == name.to_s}.first;
+    end
     
   end
 end

data/lib/xcode/scheme.rb

@@ -1,11 +1,16 @@
 require 'nokogiri'
 
 module Xcode
+  
+  class SchemeAction
+    attr_accessor :config, :name
+  end
 
   # Schemes are an XML file that describe build, test, launch and profile actions
   # For the purposes of Xcoder, we want to be able to build and test
   class Scheme
-    attr_reader :parent, :path, :name, :build_config, :build_targets
+    attr_reader :parent, :path, :name, :build_targets, :test_targets
+    attr_accessor :build_config, :archive_config, :test_config
 
     #
     # Parse all the schemes given the current project.
@@ -19,21 +24,21 @@ module Xcode
     #
     def self.find_in_workspace(workspace)
       schemes = find_in_path(workspace, workspace.path)
-      
+
       # Project level schemes
       workspace.projects.each do |project|
-        schemes+=project.schemes
+        schemes+=find_in_path(workspace, project.path)
       end
-      
+
       schemes
     end
-    
+
     # Parse all the scheme files that can be found at the given path. Schemes
     # can be defined as `shared` schemes and then `user` specific schemes. Parsing
     # the schemes will load the shared ones and then the current acting user's
     # schemes.
     #
-    # 
+    #
     # @param project or workspace in which the scheme is contained
     # @return [Array<Scheme>] the shared schemes and user specific schemes found
     #   within the project/workspace at the path defined for schemes.
@@ -43,22 +48,35 @@ module Xcode
         Xcode::Scheme.new(parent: parent, root: path, path: scheme_path)
       end
     end
-    
+
     def initialize(params={})
       @parent = params[:parent]
       @path = File.expand_path params[:path]
       @root = File.expand_path(File.join(params[:root],'..'))
       @name = File.basename(path).gsub(/\.xcscheme$/,'')
-      doc = Nokogiri::XML(open(@path))      
-      
+      doc = Nokogiri::XML(open(@path))
+
       parse_build_actions(doc)
     end
-    
-    # Returns a builder for building this scheme
+
+    #
+    # @return a builder for building this scheme
+    #
     def builder
       Xcode::Builder::SchemeBuilder.new(self)
     end
 
+    def to_s
+      "#{name} (Scheme) in #{parent}"
+    end
+    
+    #
+    # @return true if the scheme is testable, false otherwise
+    #
+    def testable?
+      !@test_config.nil?
+    end
+
     private
 
     #
@@ -84,25 +102,34 @@ module Xcode
     def self.current_user_schemes_paths(root)
       Dir["#{root}/xcuserdata/#{ENV['USER']}.xcuserdatad/xcschemes/*.xcscheme"]
     end
-    
+
     def target_from_build_reference(buildableReference)
       project_name  = buildableReference['ReferencedContainer'].gsub(/^container:/,'')
       target_name   = buildableReference['BlueprintName']
-      project_path  = File.join @root, project_name  
-      project       = Xcode.project project_path 
+      project_path  = File.join @root, project_name
+      project       = Xcode.project project_path
       project.target(target_name)
     end
-    
+
     def parse_build_actions(doc)
       # Build Config
       @build_targets = []
+      @test_targets = []
       
       @build_config = doc.xpath("//LaunchAction").first['buildConfiguration']
+      @archive_config = doc.xpath("//ArchiveAction").first['buildConfiguration']
+
+      if doc.xpath("//TestAction/Testables/TestableReference/BuildableReference").children.count>0
+        @test_config = doc.xpath("//TestAction").first['buildConfiguration']
+        doc.xpath("//TestAction/Testables/TestableReference/BuildableReference").each do |ref|
+          @test_targets << target_from_build_reference(ref)
+        end
+      end
       
       build_action_entries = doc.xpath("//BuildAction//BuildableReference").each do |ref|
-        @build_targets << target_from_build_reference(ref) 
+        @build_targets << target_from_build_reference(ref)
       end
     end
 
   end
-end
+end

data/lib/xcode/shell/command.rb

@@ -1,14 +1,32 @@
 require 'set'
+require 'tmpdir'
+require 'tempfile'
+require 'pty'
 
 module Xcode
   module Shell
+    
+    class ExecutionError < StandardError; 
+      attr_accessor :output
+      def initialize(message, output=nil)
+        super message
+        @output = output
+      end
+    end
+
     class Command
-      attr_accessor :env, :cmd, :args
+      include Xcode::TerminalOutput
+      attr_accessor :env, :cmd, :args, :show_output, :output_dir, :log_to_file, :output
 
       def initialize(cmd, environment={})
-        @cmd = cmd
+        @cmd = cmd.to_s
         @args = []
         @env = environment
+        @show_output = true
+        @pipe = nil
+        @output = []
+        @output_dir = Dir.tmpdir
+        @log_to_file = false
       end
     
       def <<(arg)
@@ -32,9 +50,65 @@ module Xcode
         # to_s==obj.to_s
         Set.new(obj.to_a) == Set.new(self.to_a)
       end
-      
-      def execute(show_output=true, &block) #:yield: output
-        Xcode::Shell.execute(self, show_output, &block)
+
+      #
+      # Attach an output pipe.  
+      #
+      # This can be any object which responds to puts and close 
+      def attach(pipe)
+        @pipe = pipe
+        @show_output = false
+      end
+            
+      #
+      # Execute the given command
+      #
+      def execute(&block) #:yield: output
+        print_output self.to_s, :debug
+        # print_task 'shell', self.to_s, :debug if show_output
+        begin
+          output_file_name = File.join(@output_dir, "xcoder-#{@cmd}-#{Time.now.strftime('%Y%m%d-%H%M%S')}")
+          
+          File.open(output_file_name, "w") do |file|          
+            PTY.spawn(to_s) do |r, w, child_pid|
+              r.sync
+              r.each_line do |line|
+                file << line
+                
+                print_input line.gsub(/\n$/,''), :debug if @show_output 
+
+                if @pipe.nil?
+                  # DEPRECATED
+                  yield(line) if block_given?
+                else
+                  @pipe << line
+                end
+                
+                @output << line
+              end 
+              Process.wait(child_pid)
+            end
+          end
+          
+          raise ExecutionError.new("Error (#{$?.exitstatus}) executing '#{to_s}'", @output) if $?.exitstatus>0        
+
+          if @log_to_file
+            print_system "Captured output to #{output_file_name}", :notice                      
+          else
+            File.delete(output_file_name)
+          end
+          
+          @output
+        rescue Xcode::Shell::ExecutionError => e          
+          print_system "Captured output to #{output_file_name}", :notice          
+          print_system "Cropped #{e.output.count - 10} lines", :notice if @output.count>10
+          @output.last(10).each do |line|
+            print_output line.strip, :error
+          end
+          raise e      
+        ensure
+          @pipe.close unless @pipe.nil?
+        end
       end
       
     end