xcodeproj 0.26.3 → 0.27.0

data/lib/xcodeproj/scheme/launch_action.rb

@@ -0,0 +1,68 @@
+require 'xcodeproj/scheme/abstract_scheme_action'
+
+module Xcodeproj
+  class XCScheme
+    # This class wraps the LaunchAction node of a .xcscheme XML file
+    #
+    class LaunchAction < AbstractSchemeAction
+      # @param [REXML::Element] node
+      #        The 'LaunchAction' XML node that this object will wrap.
+      #        If nil, will create a default XML node to use.
+      #
+      def initialize(node = nil)
+        create_xml_element_with_fallback(node, 'LaunchAction') do
+          # Add some attributes (that are not handled by this wrapper class yet but expected in the XML)
+          @xml_element.attributes['selectedDebuggerIdentifier'] = 'Xcode.DebuggerFoundation.Debugger.LLDB'
+          @xml_element.attributes['selectedLauncherIdentifier'] = 'Xcode.DebuggerFoundation.Launcher.LLDB'
+          @xml_element.attributes['launchStyle'] = '0'
+          @xml_element.attributes['useCustomWorkingDirectory'] = bool_to_string(false)
+          @xml_element.attributes['ignoresPersistentStateOnLaunch'] = bool_to_string(false)
+          @xml_element.attributes['debugDocumentVersioning'] = bool_to_string(true)
+          @xml_element.attributes['debugServiceExtension'] = 'internal'
+          @xml_element.add_element('AdditionalOptions')
+
+          # Setup default values for other (handled) attributes
+          self.build_configuration = 'Debug'
+          self.allow_location_simulation = true
+        end
+      end
+
+      # @todo handle 'launchStyle' attribute
+      # @todo handle 'useCustomWorkingDirectory attribute
+      # @todo handle 'ignoresPersistentStateOnLaunch' attribute
+      # @todo handle 'debugDocumentVersioning' attribute
+      # @todo handle 'debugServiceExtension'
+
+      # @return [Bool]
+      #         Whether or not to allow GPS location simulation when launching this target
+      #
+      def allow_location_simulation?
+        string_to_bool(@xml_element.attributes['allowLocationSimulation'])
+      end
+
+      # @param [Bool] flag
+      #        Set whether or not to allow GPS location simulation when launching this target
+      #
+      def allow_location_simulation=(flag)
+        @xml_element.attributes['allowLocationSimulation'] = bool_to_string(flag)
+      end
+
+      # @return [BuildableProductRunnable]
+      #         The BuildReference to launch when executing the Launch Action
+      #
+      def buildable_product_runnable
+        BuildableProductRunnable.new(@xml_element.elements['BuildableProductRunnable'], 0)
+      end
+
+      # @param [BuildableProductRunnable] runnable
+      #        Set the BuildableProductRunnable referencing the target to launch
+      #
+      def buildable_product_runnable=(runnable)
+        @xml_element.delete_element('BuildableProductRunnable')
+        @xml_element.add_element(runnable.xml_element) if runnable
+      end
+
+      # @todo handle 'AdditionalOptions' tag
+    end
+  end
+end

data/lib/xcodeproj/scheme/macro_expansion.rb

@@ -0,0 +1,34 @@
+module Xcodeproj
+  class XCScheme
+    # This class wraps the MacroExpansion node of a .xcscheme XML file
+    #
+    class MacroExpansion < XMLElementWrapper
+      # @param [Xcodeproj::Project::Object::AbstractTarget, REXML::Element] target_or_node
+      #        Either the Xcode target to reference,
+      #        or an existing XML 'MacroExpansion' node element
+      #        or nil to create an empty MacroExpansion object
+      #
+      def initialize(target_or_node = nil)
+        create_xml_element_with_fallback(target_or_node, 'MacroExpansion') do
+          self.buildable_reference = BuildableReference.new(target_or_node) if target_or_node
+        end
+      end
+
+      # @return [BuildableReference]
+      #         The BuildableReference this MacroExpansion refers to
+      #
+      def buildable_reference
+        @buildable_reference ||= BuildableReference.new @xml_element.elements['BuildableReference']
+      end
+
+      # @param [BuildableReference] ref
+      #        Set the BuildableReference this MacroExpansion refers to
+      #
+      def buildable_reference=(ref)
+        @xml_element.delete_element('BuildableReference')
+        @xml_element.add_element(ref.xml_element)
+        @buildable_reference = ref
+      end
+    end
+  end
+end

data/lib/xcodeproj/scheme/profile_action.rb

@@ -0,0 +1,57 @@
+require 'xcodeproj/scheme/abstract_scheme_action'
+
+module Xcodeproj
+  class XCScheme
+    # This class wraps the ProfileAction node of a .xcscheme XML file
+    #
+    class ProfileAction < AbstractSchemeAction
+      # @param [REXML::Element] node
+      #        The 'ProfileAction' XML node that this object will wrap.
+      #        If nil, will create a default XML node to use.
+      #
+      def initialize(node = nil)
+        create_xml_element_with_fallback(node, 'ProfileAction') do
+          # Add some attributes (that are not handled by this wrapper class yet but expected in the XML)
+          @xml_element.attributes['savedToolIdentifier'] = ''
+          @xml_element.attributes['useCustomWorkingDirectory'] = bool_to_string(false)
+          @xml_element.attributes['debugDocumentVersioning'] = bool_to_string(true)
+
+          # Setup default values for other (handled) attributes
+          self.build_configuration = 'Release'
+          self.should_use_launch_scheme_args_env = true
+        end
+      end
+
+      # @return [Bool]
+      #         Whether this Profile Action should use the same arguments and environment variables
+      #         as the Launch Action.
+      #
+      def should_use_launch_scheme_args_env?
+        string_to_bool(@xml_element.attributes['shouldUseLaunchSchemeArgsEnv'])
+      end
+
+      # @param [Bool] flag
+      #        Set Whether this Profile Action should use the same arguments and environment variables
+      #        as the Launch Action.
+      #
+      def should_use_launch_scheme_args_env=(flag)
+        @xml_element.attributes['shouldUseLaunchSchemeArgsEnv'] = bool_to_string(flag)
+      end
+
+      # @return [BuildableProductRunnable]
+      #         The BuildableProductRunnable to launch when launching the Profile action
+      #
+      def buildable_product_runnable
+        BuildableProductRunnable.new @xml_element.elements['BuildableProductRunnable']
+      end
+
+      # @param [BuildableProductRunnable] runnable
+      #        Set the BuildableProductRunnable referencing the target to launch when profiling
+      #
+      def buildable_product_runnable=(runnable)
+        @xml_element.delete_element('BuildableProductRunnable')
+        @xml_element.add_element(runnable.xml_element) if runnable
+      end
+    end
+  end
+end

data/lib/xcodeproj/scheme/test_action.rb

@@ -0,0 +1,123 @@
+require 'xcodeproj/scheme/abstract_scheme_action'
+
+module Xcodeproj
+  class XCScheme
+    # This class wraps the TestAction node of a .xcscheme XML file
+    #
+    class TestAction < AbstractSchemeAction
+      # @param [REXML::Element] node
+      #        The 'TestAction' XML node that this object will wrap.
+      #        If nil, will create a default XML node to use.
+      #
+      def initialize(node = nil)
+        create_xml_element_with_fallback(node, 'TestAction') do
+          @xml_element.attributes['selectedDebuggerIdentifier'] = 'Xcode.DebuggerFoundation.Debugger.LLDB'
+          @xml_element.attributes['selectedLauncherIdentifier'] = 'Xcode.DebuggerFoundation.Launcher.LLDB'
+          @xml_element.add_element('AdditionalOptions')
+          self.should_use_launch_scheme_args_env = true
+          self.build_configuration = 'Debug'
+        end
+      end
+
+      # @return [Bool]
+      #         Whether this Test Action should use the same arguments and environment variables
+      #         as the Launch Action.
+      #
+      def should_use_launch_scheme_args_env?
+        string_to_bool(@xml_element.attributes['shouldUseLaunchSchemeArgsEnv'])
+      end
+
+      # @param [Bool] flag
+      #        Set Whether this Test Action should use the same arguments and environment variables
+      #        as the Launch Action.
+      #
+      def should_use_launch_scheme_args_env=(flag)
+        @xml_element.attributes['shouldUseLaunchSchemeArgsEnv'] = bool_to_string(flag)
+      end
+
+      # @return [Array<TestableReference>]
+      #         The list of TestableReference (test bundles) associated with this Test Action
+      #
+      def testables
+        return [] unless @xml_element.elements['Testables']
+
+        @xml_element.elements['Testables'].get_elements('TestableReference').map do |node|
+          TestableReference.new(node)
+        end
+      end
+
+      # @param [TestableReference] testable
+      #        Add a TestableReference (test bundle) to this Test Action
+      #
+      def add_testable(testable)
+        testables = @xml_element.elements['Testables'] || @xml_element.add_element('Testables')
+        testables.add_element(testable.xml_element)
+      end
+
+      # @return [Array<MacroExpansion>]
+      #         The list of MacroExpansion bound with this TestAction
+      #
+      def macro_expansions
+        @xml_element.get_elements('MacroExpansion').map do |node|
+          MacroExpansion.new(node)
+        end
+      end
+
+      # @param [MacroExpansion] macro_expansion
+      #        Add a MacroExpansion to this TestAction
+      #
+      def add_macro_expansion(macro_expansion)
+        @xml_element.add_element(macro_expansion.xml_element)
+      end
+
+      #-------------------------------------------------------------------------#
+
+      class TestableReference < XMLElementWrapper
+        # @param [Xcodeproj::Project::Object::AbstractTarget, REXML::Element] target_or_node
+        #        Either the Xcode target to reference,
+        #        or an existing XML 'TestableReference' node element to reference,
+        #        or nil to create an new, empty TestableReference
+        #
+        def initialize(target_or_node = nil)
+          create_xml_element_with_fallback(target_or_node, 'TestableReference') do
+            self.skipped = false
+            add_buildable_reference BuildableReference.new(target_or_node) unless target_or_node.nil?
+          end
+        end
+
+        # @return [Bool]
+        #         Whether or not this TestableReference (test bundle) should be skipped or not
+        #
+        def skipped?
+          string_to_bool(@xml_element.attributes['skipped'])
+        end
+
+        # @param [Bool] flag
+        #        Set whether or not this TestableReference (test bundle) should be skipped or not
+        #
+        def skipped=(flag)
+          @xml_element.attributes['skipped'] = bool_to_string(flag)
+        end
+
+        # @return [Array<BuildableReference>]
+        #         The list of BuildableReferences this action will build.
+        #         (The list usually contains only one element)
+        #
+        def buildable_references
+          @xml_element.get_elements('BuildableReference').map do |node|
+            BuildableReference.new(node)
+          end
+        end
+
+        # @param [BuildableReference] ref
+        #         The BuildableReference to add to the list of targets this action will build
+        #
+        def add_buildable_reference(ref)
+          @xml_element.add_element(ref.xml_element)
+        end
+
+        # @todo handle 'AdditionalOptions' tag
+      end
+    end
+  end
+end

data/lib/xcodeproj/scheme/xml_element_wrapper.rb

@@ -0,0 +1,82 @@
+module Xcodeproj
+  class XCScheme
+    # Abstract base class used for other XCScheme classes wrapping an XML element
+    #
+    class XMLElementWrapper
+      # @return [REXML::Element]
+      #         The XML node wrapped and manipulated by this XMLElementWrapper object
+      #
+      attr_reader :xml_element
+
+      # @return [String]
+      #         The XML representation of the node this XMLElementWrapper wraps,
+      #         formatted in the same way that Xcode would.
+      def to_s
+        formatter = XMLFormatter.new(2)
+        formatter.compact = false
+        out = ''
+        formatter.write(@xml_element, out)
+        out.gsub!("<?xml version='1.0' encoding='UTF-8'?>", '')
+        out << "\n"
+        out
+      end
+
+      private
+
+      # This is a method intended to be used to facilitate the implementation of the initializers.
+      #
+      # - Create the @xml_element attribute based on the node passed as parameter, only if
+      #   that parameter is of type REXML::Element and its name matches the tag_name given.
+      # - Otherwise, create a brand new REXML::Element with the proper tag name and
+      #   execute the block given as a fallback to let the caller the chance to configure it
+      #
+      # @param [REXML::Element, *] node
+      #        The node this XMLElementWrapper is expected to wrap
+      #        or any other object (typically an AbstractTarget instance, or nil) the initializer might expect
+      #
+      # @param [String] tag_name
+      #        The expected name for the node, which will also be the name used to create the new node
+      #        if that `node` parameter is not a REXML::Element itself.
+      #
+      # @yield a parameter-less block if the `node` parameter is not actually a REXML::Element
+      #
+      # @raise Informative
+      #        If the `node` parameter is a REXML::Element instance but the node's name
+      #        doesn't match the one provided by the `tag_name` parameter.
+      #
+      def create_xml_element_with_fallback(node, tag_name)
+        if node && node.is_a?(REXML::Element)
+          raise Informative, 'Wrong XML tag name' unless node.name == tag_name
+          @xml_element = node
+        else
+          @xml_element = REXML::Element.new(tag_name)
+          yield if block_given?
+        end
+      end
+
+      # @param [Bool]
+      #        The boolean we want to represent as a string
+      #
+      # @return [String]
+      #         The string representaiton of that boolean used in the XML ('YES' or 'NO')
+      #
+      def bool_to_string(flag)
+        flag ? 'YES' : 'NO'
+      end
+
+      # @param [String]
+      #        The string representaiton of a boolean used in the XML ('YES' or 'NO')
+      #
+      # @return [Bool]
+      #        The boolean interpretation of that string
+      #
+      # @raise Informative
+      #        If the string is not representing a boolean (i.e. is neither 'YES' nor 'NO')
+      #
+      def string_to_bool(str)
+        raise Informative, 'Invalid tag value. Expected YES or NO.' unless %w(YES NO).include?(str)
+        str == 'YES'
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xcodeproj
 version: !ruby/object:Gem::Version
-  version: 0.26.3
+  version: 0.27.0
 platform: ruby
 authors:
 - Eloy Duran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-26 00:00:00.000000000 Z
+date: 2015-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -101,6 +101,17 @@ files:
 - lib/xcodeproj/project/project_helper.rb
 - lib/xcodeproj/project/uuid_generator.rb
 - lib/xcodeproj/scheme.rb
+- lib/xcodeproj/scheme/abstract_scheme_action.rb
+- lib/xcodeproj/scheme/analyze_action.rb
+- lib/xcodeproj/scheme/archive_action.rb
+- lib/xcodeproj/scheme/build_action.rb
+- lib/xcodeproj/scheme/buildable_product_runnable.rb
+- lib/xcodeproj/scheme/buildable_reference.rb
+- lib/xcodeproj/scheme/launch_action.rb
+- lib/xcodeproj/scheme/macro_expansion.rb
+- lib/xcodeproj/scheme/profile_action.rb
+- lib/xcodeproj/scheme/test_action.rb
+- lib/xcodeproj/scheme/xml_element_wrapper.rb
 - lib/xcodeproj/user_interface.rb
 - lib/xcodeproj/workspace.rb
 - lib/xcodeproj/workspace/file_reference.rb