plasmo_xcodeproj 1.21.1

data/lib/xcodeproj/scheme/abstract_scheme_action.rb

@@ -0,0 +1,100 @@
+require 'xcodeproj/scheme/xml_element_wrapper'
+require 'xcodeproj/scheme/environment_variables'
+require 'xcodeproj/scheme/command_line_arguments'
+
+module Xcodeproj
+  class XCScheme
+    # This abstract class aims to be the base class for every XxxAction class
+    # that have a #build_configuration attribute
+    #
+    class AbstractSchemeAction < XMLElementWrapper
+      # @return [String]
+      #         The build configuration associated with this action
+      #         (usually either 'Debug' or 'Release')
+      #
+      def build_configuration
+        @xml_element.attributes['buildConfiguration']
+      end
+
+      # @param [String] config_name
+      #        The build configuration to associate with this action
+      #        (usually either 'Debug' or 'Release')
+      #
+      def build_configuration=(config_name)
+        @xml_element.attributes['buildConfiguration'] = config_name
+      end
+
+      # @return [Array<ExecutionAction>]
+      #         The list of actions to run before this scheme action.
+      #         Each entry can be either a 'Run Script' or a 'Send Email' action.
+      #
+      def pre_actions
+        pre_actions = @xml_element.elements['PreActions']
+        return nil unless pre_actions
+        pre_actions.get_elements('ExecutionAction').map do |entry_node|
+          ExecutionAction.new(entry_node)
+        end
+      end
+
+      # @param [Array<ExecutionAction>] pre_actions
+      #         Set the list of actions to run before this scheme action.
+      #         Each entry can be either a 'Run Script' or a 'Send Email' action.
+      #
+      def pre_actions=(pre_actions)
+        @xml_element.delete_element('PreActions')
+        unless pre_actions.empty?
+          pre_actions_element = @xml_element.add_element('PreActions')
+          pre_actions.each do |entry_node|
+            pre_actions_element.add_element(entry_node.xml_element)
+          end
+        end
+        pre_actions
+      end
+
+      # @param [ExecutionAction] pre_action
+      #        Add an action to the list of actions to run before this scheme action.
+      #        It can be either a 'Run Script' or a 'Send Email' action.
+      #
+      def add_pre_action(pre_action)
+        pre_actions = @xml_element.elements['PreActions'] || @xml_element.add_element('PreActions')
+        pre_actions.add_element(pre_action.xml_element)
+      end
+
+      # @return [Array<ExecutionAction>]
+      #         The list of actions to run after this scheme action.
+      #         Each entry can be either a 'Run Script' or a 'Send Email' action.
+      #
+      def post_actions
+        post_actions = @xml_element.elements['PostActions']
+        return nil unless post_actions
+        post_actions.get_elements('ExecutionAction').map do |entry_node|
+          ExecutionAction.new(entry_node)
+        end
+      end
+
+      # @param [Array<ExecutionAction>] post_actions
+      #        Set the list of actions to run after this scheme action.
+      #        Each entry can be either a 'Run Script' or a 'Send Email' action.
+      #
+      def post_actions=(post_actions)
+        @xml_element.delete_element('PostActions')
+        unless post_actions.empty?
+          post_actions_element = @xml_element.add_element('PostActions')
+          post_actions.each do |entry_node|
+            post_actions_element.add_element(entry_node.xml_element)
+          end
+        end
+        post_actions
+      end
+
+      # @param [ExecutionAction] post_action
+      #        Add an action to the list of actions to run after this scheme action.
+      #        It can be either a 'Run Script' or a 'Send Email' action.
+      #
+      def add_post_action(post_action)
+        post_actions = @xml_element.elements['PostActions'] || @xml_element.add_element('PostActions')
+        post_actions.add_element(post_action.xml_element)
+      end
+    end
+  end
+end

data/lib/xcodeproj/scheme/analyze_action.rb

@@ -0,0 +1,19 @@
+require 'xcodeproj/scheme/abstract_scheme_action'
+
+module Xcodeproj
+  class XCScheme
+    # This class wraps the AnalyzeAction node of a .xcscheme XML file
+    #
+    class AnalyzeAction < AbstractSchemeAction
+      # @param [REXML::Element] node
+      #        The 'AnalyzeAction' 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, 'AnalyzeAction') do
+          self.build_configuration = 'Debug'
+        end
+      end
+    end
+  end
+end

data/lib/xcodeproj/scheme/archive_action.rb

@@ -0,0 +1,59 @@
+require 'xcodeproj/scheme/abstract_scheme_action'
+
+module Xcodeproj
+  class XCScheme
+    # This class wraps the ArchiveAction node of a .xcscheme XML file
+    #
+    class ArchiveAction < AbstractSchemeAction
+      # @param [REXML::Element] node
+      #        The 'ArchiveAction' 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, 'ArchiveAction') do
+          self.build_configuration = 'Release'
+          self.reveal_archive_in_organizer = true
+        end
+      end
+
+      # @return [Bool]
+      #         Whether the Archive will be revealed in Xcode's Organizer
+      #         after it's done building.
+      #
+      def reveal_archive_in_organizer?
+        string_to_bool(@xml_element.attributes['revealArchiveInOrganizer'])
+      end
+
+      # @param [Bool] flag
+      #        Set whether the Archive will be revealed in Xcode's Organizer
+      #        after it's done building.
+      #
+      def reveal_archive_in_organizer=(flag)
+        @xml_element.attributes['revealArchiveInOrganizer'] = bool_to_string(flag)
+      end
+
+      # @return [String]
+      #         The custom name to give to the archive.
+      #         If nil, the generated archive will have the same name as the one
+      #         set in the associated target's Build Settings for the built product.
+      #
+      def custom_archive_name
+        @xml_element.attributes['customArchiveName']
+      end
+
+      # @param [String] name
+      #        Set the custom name to use for the built archive
+      #        If nil, the customization of the archive name will be removed and
+      #        the generated archive will have the same name as the one set in the
+      #        associated target's Build Settings for the build product.
+      #
+      def custom_archive_name=(name)
+        if name
+          @xml_element.attributes['customArchiveName'] = name
+        else
+          @xml_element.delete_attribute('customArchiveName')
+        end
+      end
+    end
+  end
+end

data/lib/xcodeproj/scheme/build_action.rb

@@ -0,0 +1,298 @@
+require 'xcodeproj/scheme/xml_element_wrapper'
+
+module Xcodeproj
+  class XCScheme
+    # This class wraps the BuildAction node of a .xcscheme XML file
+    #
+    # Note: It's not a AbstractSchemeAction like the others because it is
+    # a special case of action (with no build_configuration, etc)
+    #
+    class BuildAction < XMLElementWrapper
+      # @param [REXML::Element] node
+      #        The 'BuildAction' 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, 'BuildAction') do
+          self.parallelize_buildables = true
+          self.build_implicit_dependencies = true
+        end
+      end
+
+      # @return [Bool]
+      #         Whether or not to run post actions on build failure
+      #
+      def run_post_actions_on_failure?
+        string_to_bool(@xml_element.attributes['runPostActionsOnFailure'])
+      end
+
+      # @param [Bool] flag
+      #        Set whether or not to run post actions on build failure
+      #
+      def run_post_actions_on_failure=(flag)
+        @xml_element.attributes['runPostActionsOnFailure'] = bool_to_string(flag)
+      end
+
+      # @return [Bool]
+      #         Whether or not to build the various targets in parallel
+      #
+      def parallelize_buildables?
+        string_to_bool(@xml_element.attributes['parallelizeBuildables'])
+      end
+
+      # @param [Bool] flag
+      #        Set whether or not to build the various targets in parallel
+      #
+      def parallelize_buildables=(flag)
+        @xml_element.attributes['parallelizeBuildables'] = bool_to_string(flag)
+      end
+
+      # @return [Bool]
+      #          Whether or not to detect and build implicit dependencies for each target
+      #
+      def build_implicit_dependencies?
+        string_to_bool(@xml_element.attributes['buildImplicitDependencies'])
+      end
+
+      # @param [Bool] flag
+      #        Whether or not to detect and build implicit dependencies for each target
+      #
+      def build_implicit_dependencies=(flag)
+        @xml_element.attributes['buildImplicitDependencies'] = bool_to_string(flag)
+      end
+
+      # @return [Array<ExecutionAction>]
+      #         The list of actions to run before this scheme action.
+      #         Each entry can be either a 'Run Script' or a 'Send Email' action.
+      #
+      def pre_actions
+        pre_actions = @xml_element.elements['PreActions']
+        return nil unless pre_actions
+        pre_actions.get_elements('ExecutionAction').map do |entry_node|
+          ExecutionAction.new(entry_node)
+        end
+      end
+
+      # @param [Array<ExecutionAction>] pre_actions
+      #        Set the list of actions to run before this scheme action.
+      #        Each entry can be either a 'Run Script' or a 'Send Email' action.
+      #
+      def pre_actions=(pre_actions)
+        @xml_element.delete_element('PreActions')
+        unless pre_actions.empty?
+          pre_actions_element = @xml_element.add_element('PreActions')
+          pre_actions.each do |entry_node|
+            pre_actions_element.add_element(entry_node.xml_element)
+          end
+        end
+        pre_actions
+      end
+
+      # @param [ExecutionAction] pre_action
+      #        Add an action to the list of actions to run before this scheme action.
+      #        It can be either a 'Run Script' or a 'Send Email' action.
+      #
+      def add_pre_action(pre_action)
+        pre_actions = @xml_element.elements['PreActions'] || @xml_element.add_element('PreActions')
+        pre_actions.add_element(pre_action.xml_element)
+      end
+
+      # @return [Array<ExecutionAction>]
+      #         The list of actions to run after this scheme action.
+      #         Each entry can be either a 'Run Script' or a 'Send Email' action.
+      #
+      def post_actions
+        post_actions = @xml_element.elements['PostActions']
+        return nil unless post_actions
+        post_actions.get_elements('ExecutionAction').map do |entry_node|
+          ExecutionAction.new(entry_node)
+        end
+      end
+
+      # @param [Array<ExecutionAction>] post_actions
+      #        Set the list of actions to run after this scheme action.
+      #        Each entry can be either a 'Run Script' or a 'Send Email' action.
+      #
+      def post_actions=(post_actions)
+        @xml_element.delete_element('PostActions')
+        unless post_actions.empty?
+          post_actions_element = @xml_element.add_element('PostActions')
+          post_actions.each do |entry_node|
+            post_actions_element.add_element(entry_node.xml_element)
+          end
+        end
+        post_actions
+      end
+
+      # @param [ExecutionAction] post_action
+      #        Add an action to the list of actions to run after this scheme action.
+      #        It can be either a 'Run Script' or a 'Send Email' action.
+      #
+      def add_post_action(post_action)
+        post_actions = @xml_element.elements['PostActions'] || @xml_element.add_element('PostActions')
+        post_actions.add_element(post_action.xml_element)
+      end
+
+      # @return [Array<BuildAction::Entry>]
+      #         The list of BuildActionEntry nodes associated with this Build Action.
+      #         Each entry represent a target to build and tells for which action it's needed to be built.
+      #
+      def entries
+        entries = @xml_element.elements['BuildActionEntries']
+        return nil unless entries
+        entries.get_elements('BuildActionEntry').map do |entry_node|
+          BuildAction::Entry.new(entry_node)
+        end
+      end
+
+      # @param [Array<BuildAction::Entry>] entries
+      #        Sets the list of BuildActionEntry nodes associated with this Build Action.
+      #
+      def entries=(entries)
+        @xml_element.delete_element('BuildActionEntries')
+        unless entries.empty?
+          entries_element = @xml_element.add_element('BuildActionEntries')
+          entries.each do |entry_node|
+            entries_element.add_element(entry_node.xml_element)
+          end
+        end
+        entries
+      end
+
+      # @param [BuildAction::Entry] entry
+      #        The BuildActionEntry to add to the list of targets to build for the various actions
+      #
+      def add_entry(entry)
+        entries = @xml_element.elements['BuildActionEntries'] || @xml_element.add_element('BuildActionEntries')
+        entries.add_element(entry.xml_element)
+      end
+
+      #-------------------------------------------------------------------------#
+
+      class Entry < XMLElementWrapper
+        # @param [Xcodeproj::Project::Object::AbstractTarget, REXML::Element] target_or_node
+        #        Either the Xcode target to reference,
+        #        or an existing XML 'BuildActionEntry' node element to reference,
+        #        or nil to create an new, empty Entry with default values
+        #
+        def initialize(target_or_node = nil)
+          create_xml_element_with_fallback(target_or_node, 'BuildActionEntry') do
+            # Check target type to configure the default entry attributes accordingly
+            is_test_target = false
+            is_app_target = false
+            if target_or_node && target_or_node.is_a?(::Xcodeproj::Project::Object::PBXNativeTarget)
+              test_types = [Constants::PRODUCT_TYPE_UTI[:octest_bundle],
+                            Constants::PRODUCT_TYPE_UTI[:unit_test_bundle],
+                            Constants::PRODUCT_TYPE_UTI[:ui_test_bundle]]
+              app_types = [Constants::PRODUCT_TYPE_UTI[:application]]
+              is_test_target = test_types.include?(target_or_node.product_type)
+              is_app_target = app_types.include?(target_or_node.product_type)
+            end
+
+            self.build_for_testing   = is_test_target
+            self.build_for_running   = is_app_target
+            self.build_for_profiling = is_app_target
+            self.build_for_archiving = is_app_target
+            self.build_for_analyzing = true
+
+            add_buildable_reference BuildableReference.new(target_or_node) if target_or_node
+          end
+        end
+
+        # @return [Bool]
+        #         Whether or not to build this target when building for Testing
+        #
+        def build_for_testing?
+          string_to_bool(@xml_element.attributes['buildForTesting'])
+        end
+
+        # @param [Bool]
+        #        Set whether or not to build this target when building for Testing
+        #
+        def build_for_testing=(flag)
+          @xml_element.attributes['buildForTesting'] = bool_to_string(flag)
+        end
+
+        # @return [Bool]
+        #         Whether or not to build this target when building for Running
+        #
+        def build_for_running?
+          string_to_bool(@xml_element.attributes['buildForRunning'])
+        end
+
+        # @param [Bool]
+        #        Set whether or not to build this target when building for Running
+        #
+        def build_for_running=(flag)
+          @xml_element.attributes['buildForRunning'] = bool_to_string(flag)
+        end
+
+        # @return [Bool]
+        #         Whether or not to build this target when building for Profiling
+        #
+        def build_for_profiling?
+          string_to_bool(@xml_element.attributes['buildForProfiling'])
+        end
+
+        # @param [Bool]
+        #        Set whether or not to build this target when building for Profiling
+        #
+        def build_for_profiling=(flag)
+          @xml_element.attributes['buildForProfiling'] = bool_to_string(flag)
+        end
+
+        # @return [Bool]
+        #         Whether or not to build this target when building for Archiving
+        #
+        def build_for_archiving?
+          string_to_bool(@xml_element.attributes['buildForArchiving'])
+        end
+
+        # @param [Bool]
+        #        Set whether or not to build this target when building for Archiving
+        #
+        def build_for_archiving=(flag)
+          @xml_element.attributes['buildForArchiving'] = bool_to_string(flag)
+        end
+
+        # @return [Bool]
+        #         Whether or not to build this target when building for Analyzing
+        #
+        def build_for_analyzing?
+          string_to_bool(@xml_element.attributes['buildForAnalyzing'])
+        end
+
+        # @param [Bool]
+        #        Set whether or not to build this target when building for Analyzing
+        #
+        def build_for_analyzing=(flag)
+          @xml_element.attributes['buildForAnalyzing'] = bool_to_string(flag)
+        end
+
+        # @return [Array<BuildableReference>]
+        #         The list of BuildableReferences this entry 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 entry will build
+        #
+        def add_buildable_reference(ref)
+          @xml_element.add_element(ref.xml_element)
+        end
+
+        # @param [BuildableReference] ref
+        #         The BuildableReference to remove from the list of targets this entry will build
+        #
+        def remove_buildable_reference(ref)
+          @xml_element.delete_element(ref.xml_element)
+        end
+      end
+    end
+  end
+end

data/lib/xcodeproj/scheme/buildable_product_runnable.rb

@@ -0,0 +1,55 @@
+module Xcodeproj
+  class XCScheme
+    # This class wraps the BuildableProductRunnable node of a .xcscheme XML file
+    #
+    # A BuildableProductRunnable is a product that is both buildable
+    # (it contains a BuildableReference) and runnable (it can be launched and debugged)
+    #
+    class BuildableProductRunnable < XMLElementWrapper
+      # @param [Xcodeproj::Project::Object::AbstractTarget, REXML::Element] target_or_node
+      #        Either the Xcode target to reference,
+      #        or an existing XML 'BuildableProductRunnable' node element to reference
+      #        or nil to create an new, empty BuildableProductRunnable
+      #
+      # @param [#to_s] runnable_debugging_mode
+      #        The debugging mode (usually '0')
+      #
+      def initialize(target_or_node = nil, runnable_debugging_mode = nil)
+        create_xml_element_with_fallback(target_or_node, 'BuildableProductRunnable') do
+          self.buildable_reference = BuildableReference.new(target_or_node) if target_or_node
+          @xml_element.attributes['runnableDebuggingMode'] = runnable_debugging_mode.to_s if runnable_debugging_mode
+        end
+      end
+
+      # @return [String]
+      #         The Runnable debugging mode (usually either empty or equal to '0')
+      #
+      def runnable_debugging_mode
+        @xml_element.attributes['runnableDebuggingMode']
+      end
+
+      # @param [String] value
+      #        Set the runnable debugging mode of this buildable product runnable
+      #
+      def runnable_debugging_mode=(value)
+        @xml_element.attributes['runnableDebuggingMode'] = value.to_s
+      end
+
+      # @return [BuildableReference]
+      #         The Buildable Reference this Buildable Product Runnable is gonna build and run
+      #
+      def buildable_reference
+        @buildable_reference ||= BuildableReference.new @xml_element.elements['BuildableReference']
+      end
+
+      # @param [BuildableReference] ref
+      #        Set the Buildable Reference this Buildable Product Runnable is gonna build and run
+      #
+      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/buildable_reference.rb

@@ -0,0 +1,129 @@
+module Xcodeproj
+  class XCScheme
+    # This class wraps the BuildableReference node of a .xcscheme XML file
+    #
+    # A BuildableReference is a reference to a buildable product (which is
+    # typically is synonymous for an Xcode target)
+    #
+    class BuildableReference < XMLElementWrapper
+      # @param [Xcodeproj::Project::Object::AbstractTarget, REXML::Element] target_or_node
+      #        Either the Xcode target to reference,
+      #        or an existing XML 'BuildableReference' node element to reference
+      #
+      # @param [Xcodeproj::Project] the root project to reference from
+      #                             (when nil the project of the target is used)
+      #
+      def initialize(target_or_node, root_project = nil)
+        create_xml_element_with_fallback(target_or_node, 'BuildableReference') do
+          @xml_element.attributes['BuildableIdentifier'] = 'primary'
+          set_reference_target(target_or_node, true, root_project) if target_or_node
+        end
+      end
+
+      # @return [String]
+      #         The name of the target this Buildable Reference points to
+      #
+      def target_name
+        @xml_element.attributes['BlueprintName']
+      end
+
+      # @return [String]
+      #         The Unique Identifier of the target (target.uuid) this Buildable Reference points to.
+      #
+      # @note You can use this to `#find` the `Xcodeproj::Project::Object::AbstractTarget`
+      #       instance in your Xcodeproj::Project object.
+      #       e.g. `project.targets.find { |t| t.uuid == ref.target_uuid }`
+      #
+      def target_uuid
+        @xml_element.attributes['BlueprintIdentifier']
+      end
+
+      # @return [String]
+      #         The string representing the container of that target.
+      #         Typically in the form of 'container:xxxx.xcodeproj'
+      #
+      def target_referenced_container
+        @xml_element.attributes['ReferencedContainer']
+      end
+
+      # Set the BlueprintIdentifier (target.uuid), BlueprintName (target.name)
+      #     and TerefencedContainer (URI pointing to target's projet) all at once
+      #
+      # @param [Xcodeproj::Project::Object::AbstractTarget] target
+      #        The target this BuildableReference refers to.
+      #
+      # @param [Xcodeproj::Project] the root project to reference from
+      #                             (when nil the project of the target is used)
+      #
+      # @param [Bool] override_buildable_name
+      #        If true, buildable_name will also be updated by computing a name from the target
+      #
+      def set_reference_target(target, override_buildable_name = false, root_project = nil)
+        # note, the order of assignment here is important, it determines the order of serialization in the xml
+        # this matches the order that Xcode generates
+        @xml_element.attributes['BlueprintIdentifier'] = target.uuid
+        self.buildable_name = construct_buildable_name(target) if override_buildable_name
+        @xml_element.attributes['BlueprintName'] = target.name
+        @xml_element.attributes['ReferencedContainer'] = construct_referenced_container_uri(target, root_project)
+      end
+
+      # @return [String]
+      #         The name of the final product when building this Buildable Reference
+      #
+      def buildable_name
+        @xml_element.attributes['BuildableName']
+      end
+
+      # @param [String] value
+      #        Set the name of the final product when building this Buildable Reference
+      #
+      def buildable_name=(value)
+        @xml_element.attributes['BuildableName'] = value
+      end
+
+      #-------------------------------------------------------------------------#
+
+      private
+
+      # @!group Private helpers
+
+      # @param [Xcodeproj::Project::Object::AbstractTarget] target
+      #
+      # @return [String] The buildable name of the scheme.
+      #
+      def construct_buildable_name(build_target)
+        case build_target.isa
+        when 'PBXNativeTarget'
+          File.basename(build_target.product_reference.path)
+        when 'PBXAggregateTarget'
+          build_target.name
+        else
+          raise ArgumentError, "Unsupported build target type #{build_target.isa}"
+        end
+      end
+
+      # @param [Xcodeproj::Project::Object::AbstractTarget] target
+      #
+      # @param [Xcodeproj::Project] the root project to reference from
+      #                             (when nil the project of the target is used)
+      #
+      # @return [String] A string in the format "container:[path to the project
+      #                  file relative to the project_dir_path, always ending with
+      #                  the actual project directory name]"
+      #
+      def construct_referenced_container_uri(target, root_project = nil)
+        target_project = target.project
+        root_project ||= target_project
+        root_project_dir_path = root_project.root_object.project_dir_path
+        path = if !root_project_dir_path.to_s.empty?
+                 root_project.path + root_project_dir_path
+               else
+                 root_project.project_dir
+               end
+        relative_path = target_project.path.relative_path_from(path).to_s
+        relative_path = target_project.path.basename if relative_path == '.'
+        "container:#{relative_path}"
+      end
+    end
+  end
+end