plasmo_xcodeproj 1.21.1

data/lib/xcodeproj/scheme/command_line_arguments.rb

@@ -0,0 +1,162 @@
+require 'xcodeproj/scheme/xml_element_wrapper'
+
+module Xcodeproj
+  class XCScheme
+    COMMAND_LINE_ARGS_NODE = 'CommandLineArguments'.freeze
+    COMMAND_LINE_ARG_NODE = 'CommandLineArgument'.freeze
+
+    # This class wraps the CommandLineArguments node of a .xcscheme XML file. This
+    # is just a container of CommandLineArgument objects. It can either appear on a
+    # LaunchAction or TestAction scheme group.
+    #
+    class CommandLineArguments < XMLElementWrapper
+      # @param [nil,REXML::Element,Array<CommandLineArgument>,Array<Hash{Symbol => String,Bool}>] node_or_arguments
+      #        The 'CommandLineArguments' XML node, or list of command line arguments, that this object represents.
+      #          - If nil, an empty 'CommandLineArguments' XML node will be created
+      #          - If an REXML::Element, it must be named 'CommandLineArguments'
+      #          - If an Array of objects or Hashes, they'll each be passed to {#assign_argument}
+      #
+      def initialize(node_or_arguments = nil)
+        create_xml_element_with_fallback(node_or_arguments, COMMAND_LINE_ARGS_NODE) do
+          @all_arguments = []
+          node_or_arguments.each { |var| assign_argument(var) } unless node_or_arguments.nil?
+        end
+      end
+
+      # @return [Array<CommandLineArgument>]
+      #         The key value pairs currently set in @xml_element
+      #
+      def all_arguments
+        @all_arguments ||= @xml_element.get_elements(COMMAND_LINE_ARG_NODE).map { |argument| CommandLineArgument.new(argument) }
+      end
+
+      # Adds a given argument to the set of command line arguments, or replaces it if that key already exists
+      #
+      # @param [CommandLineArgument,Hash{Symbol => String,Bool}] argument
+      #        The argument to add or update, backed by an CommandLineArgument node.
+      #          - If an CommandLineArgument, the previous reference will still be valid
+      #          - If a Hash, must conform to {CommandLineArgument#initialize} requirements
+      # @return [Array<CommandLineArgument>]
+      #         The new set of command line arguments after addition
+      #
+      def assign_argument(argument)
+        command_line_arg = if argument.is_a?(CommandLineArgument)
+                             argument
+                           else
+                             CommandLineArgument.new(argument)
+                           end
+        all_arguments.each { |existing_var| remove_argument(existing_var) if existing_var.argument == command_line_arg.argument }
+        @xml_element.add_element(command_line_arg.xml_element)
+        @all_arguments << command_line_arg
+      end
+
+      # Removes a specified argument (by string or object) from the set of command line arguments
+      #
+      # @param [CommandLineArgument,String] argument
+      #        The argument to remove
+      # @return [Array<CommandLineArgument>]
+      #         The new set of command line arguments after removal
+      #
+      def remove_argument(argument)
+        command_line_arg = if argument.is_a?(CommandLineArgument)
+                             argument
+                           else
+                             CommandLineArgument.new(argument)
+                           end
+        raise "Unexpected parameter type: #{command_line_arg.class}" unless command_line_arg.is_a?(CommandLineArgument)
+        @xml_element.delete_element(command_line_arg.xml_element)
+        @all_arguments -= [command_line_arg]
+      end
+
+      # @param [String] key
+      #        The key to lookup
+      # @return [CommandLineArgument] argument
+      #         Returns the matching command line argument for a specified key
+      #
+      def [](argument)
+        all_arguments.find { |var| var.argument == argument }
+      end
+
+      # Assigns a value for a specified key
+      #
+      # @param [String] key
+      #        The key to update in the command line arguments
+      # @param [String] value
+      #        The value to lookup
+      # @return [CommandLineArgument] argument
+      #         The newly updated command line argument
+      #
+      def []=(argument, enabled)
+        assign_argument(:argument => argument, :enabled => enabled)
+        self[argument]
+      end
+
+      # @return [Array<Hash{Symbol => String,Bool}>]
+      #         The current command line arguments represented as an array
+      #
+      def to_a
+        all_arguments.map(&:to_h)
+      end
+    end
+
+    # This class wraps the CommandLineArgument node of a .xcscheme XML file.
+    # Environment arguments are accessible via the NSDictionary returned from
+    # [[NSProcessInfo processInfo] arguments] in your app code.
+    #
+    class CommandLineArgument < XMLElementWrapper
+      # @param [nil,REXML::Element,Hash{Symbol => String,Bool}] node_or_argument
+      #        - If nil, it will create a default XML node to use
+      #        - If a REXML::Element, should be a <CommandLineArgument> XML node to wrap
+      #        - If a Hash, must contain keys :key and :value (Strings) and optionally :enabled (Boolean)
+      #
+      def initialize(node_or_argument)
+        create_xml_element_with_fallback(node_or_argument, COMMAND_LINE_ARG_NODE) do
+          raise "Must pass a Hash with 'argument' and 'enabled'!" unless node_or_argument.is_a?(Hash) &&
+              node_or_argument.key?(:argument) && node_or_argument.key?(:enabled)
+
+          @xml_element.attributes['argument'] = node_or_argument[:argument]
+          @xml_element.attributes['isEnabled'] = if node_or_argument.key?(:enabled)
+                                                   bool_to_string(node_or_argument[:enabled])
+                                                 else
+                                                   bool_to_string(false)
+                                                 end
+        end
+      end
+
+      # Returns the CommandLineArgument's key
+      # @return [String]
+      #
+      def argument
+        @xml_element.attributes['argument']
+      end
+
+      # Sets the CommandLineArgument's key
+      # @param [String] key
+      #
+      def argument=(argument)
+        @xml_element.attributes['argument'] = argument
+      end
+
+      # Returns the CommandLineArgument's enabled state
+      # @return [Bool]
+      #
+      def enabled
+        string_to_bool(@xml_element.attributes['isEnabled'])
+      end
+
+      # Sets the CommandLineArgument's enabled state
+      # @param [Bool] enabled
+      #
+      def enabled=(enabled)
+        @xml_element.attributes['isEnabled'] = bool_to_string(enabled)
+      end
+
+      # @return [Hash{:key => String, :value => String, :enabled => Bool}]
+      #         The command line argument XML node with attributes converted to a representative Hash
+      #
+      def to_h
+        { :argument => argument, :enabled => enabled }
+      end
+    end
+  end
+end

data/lib/xcodeproj/scheme/environment_variables.rb

@@ -0,0 +1,170 @@
+require 'xcodeproj/scheme/xml_element_wrapper'
+
+module Xcodeproj
+  class XCScheme
+    VARIABLES_NODE = 'EnvironmentVariables'
+    VARIABLE_NODE = 'EnvironmentVariable'
+
+    # This class wraps the EnvironmentVariables node of a .xcscheme XML file. This
+    # is just a container of EnvironmentVariable objects. It can either appear on a
+    # LaunchAction or TestAction scheme group.
+    #
+    class EnvironmentVariables < XMLElementWrapper
+      # @param [nil,REXML::Element,Array<EnvironmentVariable>,Array<Hash{Symbol => String,Bool}>] node_or_variables
+      #        The 'EnvironmentVariables' XML node, or list of environment variables, that this object represents.
+      #          - If nil, an empty 'EnvironmentVariables' XML node will be created
+      #          - If an REXML::Element, it must be named 'EnvironmentVariables'
+      #          - If an Array of objects or Hashes, they'll each be passed to {#assign_variable}
+      #
+      def initialize(node_or_variables = nil)
+        create_xml_element_with_fallback(node_or_variables, VARIABLES_NODE) do
+          @all_variables = []
+          node_or_variables.each { |var| assign_variable(var) } unless node_or_variables.nil?
+        end
+      end
+
+      # @return [Array<EnvironmentVariable>]
+      #         The key value pairs currently set in @xml_element
+      #
+      def all_variables
+        @all_variables ||= @xml_element.get_elements(VARIABLE_NODE).map { |variable| EnvironmentVariable.new(variable) }
+      end
+
+      # Adds a given variable to the set of environment variables, or replaces it if that key already exists
+      #
+      # @param [EnvironmentVariable,Hash{Symbol => String,Bool}] variable
+      #        The variable to add or update, backed by an EnvironmentVariable node.
+      #          - If an EnvironmentVariable, the previous reference will still be valid
+      #          - If a Hash, must conform to {EnvironmentVariable#initialize} requirements
+      # @return [Array<EnvironmentVariable>]
+      #         The new set of environment variables after addition
+      #
+      def assign_variable(variable)
+        env_var = variable.is_a?(EnvironmentVariable) ? variable : EnvironmentVariable.new(variable)
+        all_variables.each { |existing_var| remove_variable(existing_var) if existing_var.key == env_var.key }
+        @xml_element.add_element(env_var.xml_element)
+        @all_variables << env_var
+      end
+
+      # Removes a specified variable (by string or object) from the set of environment variables
+      #
+      # @param [EnvironmentVariable,String] variable
+      #        The variable to remove
+      # @return [Array<EnvironmentVariable>]
+      #         The new set of environment variables after removal
+      #
+      def remove_variable(variable)
+        env_var = variable.is_a?(EnvironmentVariable) ? variable : all_variables.find { |var| var.key == variable }
+        raise "Unexpected parameter type: #{env_var.class}" unless env_var.is_a?(EnvironmentVariable)
+        @xml_element.delete_element(env_var.xml_element)
+        @all_variables -= [env_var]
+      end
+
+      # @param [String] key
+      #        The key to lookup
+      # @return [EnvironmentVariable] variable
+      #         Returns the matching environment variable for a specified key
+      #
+      def [](key)
+        all_variables.find { |var| var.key == key }
+      end
+
+      # Assigns a value for a specified key
+      #
+      # @param [String] key
+      #        The key to update in the environment variables
+      # @param [String] value
+      #        The value to lookup
+      # @return [EnvironmentVariable] variable
+      #         The newly updated environment variable
+      #
+      def []=(key, value)
+        assign_variable(:key => key, :value => value)
+        self[key]
+      end
+
+      # @return [Array<Hash{Symbol => String,Bool}>]
+      #         The current environment variables represented as an array
+      #
+      def to_a
+        all_variables.map(&:to_h)
+      end
+    end
+
+    # This class wraps the EnvironmentVariable node of a .xcscheme XML file.
+    # Environment variables are accessible via the NSDictionary returned from
+    # [[NSProcessInfo processInfo] environment] in your app code.
+    #
+    class EnvironmentVariable < XMLElementWrapper
+      # @param [nil,REXML::Element,Hash{Symbol => String,Bool}] node_or_variable
+      #        - If nil, it will create a default XML node to use
+      #        - If a REXML::Element, should be a <EnvironmentVariable> XML node to wrap
+      #        - If a Hash, must contain keys :key and :value (Strings) and optionally :enabled (Boolean)
+      #
+      def initialize(node_or_variable)
+        create_xml_element_with_fallback(node_or_variable, VARIABLE_NODE) do
+          raise "Must pass a Hash with 'key' and 'value'!" unless node_or_variable.is_a?(Hash) &&
+              node_or_variable.key?(:key) && node_or_variable.key?(:value)
+
+          @xml_element.attributes['key'] = node_or_variable[:key]
+          @xml_element.attributes['value'] = node_or_variable[:value]
+
+          @xml_element.attributes['isEnabled'] = if node_or_variable.key?(:enabled)
+                                                   bool_to_string(node_or_variable[:enabled])
+                                                 else
+                                                   bool_to_string(true)
+                                                 end
+        end
+      end
+
+      # Returns the EnvironmentValue's key
+      # @return [String]
+      #
+      def key
+        @xml_element.attributes['key']
+      end
+
+      # Sets the EnvironmentValue's key
+      # @param [String] key
+      #
+      def key=(key)
+        @xml_element.attributes['key'] = key
+      end
+
+      # Returns the EnvironmentValue's value
+      # @return [String]
+      #
+      def value
+        @xml_element.attributes['value']
+      end
+
+      # Sets the EnvironmentValue's value
+      # @param [String] value
+      #
+      def value=(value)
+        @xml_element.attributes['value'] = value
+      end
+
+      # Returns the EnvironmentValue's enabled state
+      # @return [Bool]
+      #
+      def enabled
+        string_to_bool(@xml_element.attributes['isEnabled'])
+      end
+
+      # Sets the EnvironmentValue's enabled state
+      # @param [Bool] enabled
+      #
+      def enabled=(enabled)
+        @xml_element.attributes['isEnabled'] = bool_to_string(enabled)
+      end
+
+      # @return [Hash{:key => String, :value => String, :enabled => Bool}]
+      #         The environment variable XML node with attributes converted to a representative Hash
+      #
+      def to_h
+        { :key => key, :value => value, :enabled => enabled }
+      end
+    end
+  end
+end

data/lib/xcodeproj/scheme/execution_action.rb

@@ -0,0 +1,86 @@
+module Xcodeproj
+  class XCScheme
+    # This class wraps the ExecutionAction node of a .xcscheme XML file
+    #
+    class ExecutionAction < XMLElementWrapper
+      # @param [REXML::Element] node
+      #        The 'ExecutionAction' XML node that this object will wrap.
+      #        If nil, will create an empty one
+      #
+      # @param [Symbol] action_type
+      #        One of `EXECUTION_ACTION_TYPE.keys`
+      #
+      def initialize(node = nil, action_type = nil)
+        create_xml_element_with_fallback(node, 'ExecutionAction') do
+          type = action_type || node.action_type
+          raise "[Xcodeproj] Invalid ActionType `#{type}`" unless Constants::EXECUTION_ACTION_TYPE.keys.include?(type)
+          @xml_element.attributes['ActionType'] = Constants::EXECUTION_ACTION_TYPE[type]
+        end
+      end
+
+      # @return [String]
+      #         The ActionType of this ExecutionAction. One of two values:
+      #
+      #         Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.ShellScriptAction,
+      #         Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.SendEmailAction
+      #
+      def action_type
+        @xml_element.attributes['ActionType']
+      end
+
+      # @return [ShellScriptActionContent]
+      #         If action_type is 'Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.ShellScriptAction'
+      #         returns the contents of the shell script to run pre/post action.
+      #
+      # @return [SendEmailActionContent]
+      #         If action_type is 'Xcode.IDEStandardExecutionActionsCore.ExecutionActionType.SendEmailAction'
+      #         returns the contents of the email to send pre/post action.
+      #
+      def action_content
+        case action_type
+        when Constants::EXECUTION_ACTION_TYPE[:shell_script]
+          ShellScriptActionContent.new(@xml_element.elements['ActionContent'])
+        when Constants::EXECUTION_ACTION_TYPE[:send_email]
+          SendEmailActionContent.new(@xml_element.elements['ActionContent'])
+        else
+          raise "[Xcodeproj] Invalid ActionType `#{action_type}`"
+        end
+      end
+
+      # @param [ShellScriptActionContent, SendEmailActionContent] value
+      #        Set either the contents of the shell script to run pre/post action
+      #        or the contents of the email to send pre/post action.
+      #
+      def action_content=(value)
+        raise "[Xcodeproj] Invalid ActionContent `#{value.class}` for " \
+          "ActionType `#{action_type}`" unless valid_action_content?(value)
+
+        @xml_element.delete_element('ActionContent')
+        @xml_element.add_element(value.xml_element)
+      end
+
+      #-------------------------------------------------------------------------#
+
+      private
+
+      # @!group Private helpers
+
+      # @return [Bool]
+      #         True if value (ActionContent) is valid for current action_type
+      #
+      # @param [ShellScriptActionContent, SendEmailActionContent] value
+      #        Checks if value matches the expected action_type if present.
+      #
+      def valid_action_content?(value)
+        case action_type
+        when Constants::EXECUTION_ACTION_TYPE[:shell_script]
+          value.is_a?(ShellScriptActionContent)
+        when Constants::EXECUTION_ACTION_TYPE[:send_email]
+          value.is_a?(SendEmailActionContent)
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/xcodeproj/scheme/launch_action.rb

@@ -0,0 +1,179 @@
+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
+          self.build_configuration = 'Debug'
+
+          # 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'
+
+          # Setup default values for other (handled) attributes
+          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 [LocationScenarioReference]
+      #         The LocationScenarioReference to simulate a GPS location when executing the Launch Action
+      #
+      def location_scenario_reference?
+        LocationScenarioReference.new(@xml_element.elements['LocationScenarioReference'])
+      end
+
+      # @return [LocationScenarioReference]
+      #         Set the LocationScenarioReference which simulates a GPS location when executing the Launch Action
+      #
+      def location_scenario_reference=(reference)
+        @xml_element.delete_element('LocationScenarioReference')
+        @xml_element.add_element(reference.xml_element) if reference
+      end
+
+      # @return [Bool]
+      #         Whether this Build Action should disable detection of UI API misuse
+      #         from background threads
+      #
+      def disable_main_thread_checker?
+        string_to_bool(@xml_element.attributes['disableMainThreadChecker'])
+      end
+
+      # @param [Bool] flag
+      #        Set whether this Build Action should disable detection of UI API misuse
+      #        from background threads
+      #
+      def disable_main_thread_checker=(flag)
+        @xml_element.attributes['disableMainThreadChecker'] = bool_to_string(flag)
+      end
+
+      # @return [Bool]
+      #         Whether UI API misuse from background threads detection should pause execution.
+      #         This flag is ignored when the thread checker disabled
+      #         ([disable_main_thread_checker] flag).
+      #
+      def stop_on_every_main_thread_checker_issue?
+        string_to_bool(@xml_element.attributes['stopOnEveryMainThreadCheckerIssue'])
+      end
+
+      # @param [Bool] flag
+      #         Set whether UI API misuse from background threads detection should pause execution.
+      #         This flag is ignored when the thread checker disabled
+      #         ([disable_main_thread_checker] flag).
+      #
+      def stop_on_every_main_thread_checker_issue=(flag)
+        @xml_element.attributes['stopOnEveryMainThreadCheckerIssue'] = bool_to_string(flag)
+      end
+
+      # @return [String]
+      #         The launch automatically substyle
+      #
+      def launch_automatically_substyle
+        @xml_element.attributes['launchAutomaticallySubstyle']
+      end
+
+      # @param [String] flag
+      #        Set the launch automatically substyle ('2' for extensions)
+      #
+      def launch_automatically_substyle=(value)
+        @xml_element.attributes['launchAutomaticallySubstyle'] = value.to_s
+      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
+
+      # @return [EnvironmentVariables]
+      #         Returns the EnvironmentVariables that will be defined at app launch
+      #
+      def environment_variables
+        EnvironmentVariables.new(@xml_element.elements[XCScheme::VARIABLES_NODE])
+      end
+
+      # @param [EnvironmentVariables,nil] env_vars
+      #        Sets the EnvironmentVariables that will be defined at app launch
+      #
+      def environment_variables=(env_vars)
+        @xml_element.delete_element(XCScheme::VARIABLES_NODE)
+        @xml_element.add_element(env_vars.xml_element) if env_vars
+        env_vars
+      end
+
+      # @todo handle 'AdditionalOptions' tag
+
+      # @return [CommandLineArguments]
+      #         Returns the CommandLineArguments that will be passed at app launch
+      #
+      def command_line_arguments
+        CommandLineArguments.new(@xml_element.elements[XCScheme::COMMAND_LINE_ARGS_NODE])
+      end
+
+      # @return [CommandLineArguments] arguments
+      #         Sets the CommandLineArguments that will be passed at app launch
+      #
+      def command_line_arguments=(arguments)
+        @xml_element.delete_element(XCScheme::COMMAND_LINE_ARGS_NODE)
+        @xml_element.add_element(arguments.xml_element) if arguments
+        arguments
+      end
+
+      # @return [Array<MacroExpansion>]
+      #         The list of MacroExpansion bound with this LaunchAction
+      #
+      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 LaunchAction
+      #
+      def add_macro_expansion(macro_expansion)
+        @xml_element.add_element(macro_expansion.xml_element)
+      end
+    end
+  end
+end

data/lib/xcodeproj/scheme/location_scenario_reference.rb

@@ -0,0 +1,49 @@
+module Xcodeproj
+  class XCScheme
+    # This class wraps the LocationScenarioReference node of a .xcscheme XML file
+    #
+    # A LocationScenarioReference is a reference to a simulated GPS location associated
+    # with a scheme's launch action
+    #
+    class LocationScenarioReference < XMLElementWrapper
+      # @param [Xcodeproj::Project::Object::AbstractTarget, REXML::Element] target_or_node
+      #        Either the Xcode target to reference,
+      #        or an existing XML 'LocationScenarioReference' node element to reference
+      #
+      def initialize(target_or_node)
+        create_xml_element_with_fallback(target_or_node, 'LocationScenarioReference') do
+          self.identifier = ''
+          self.reference_type = '0'
+        end
+      end
+
+      # @return [String]
+      #         The identifier of a built-in location scenario reference, or a path to a GPX file
+      #
+      def identifier
+        @xml_element.attributes['identifier']
+      end
+
+      # @param [String] value
+      #        Set the identifier for the location scenario reference
+      #
+      def identifier=(value)
+        @xml_element.attributes['identifier'] = value
+      end
+
+      # @return [String]
+      #         The reference type is 0 when using a custom GPX file, or 1 when using a built-in location reference
+      #
+      def reference_type
+        @xml_element.attributes['referenceType']
+      end
+
+      # @param [String] value
+      #        Set the reference type for the location scenario reference
+      #
+      def reference_type=(value)
+        @xml_element.attributes['referenceType'] = value
+      end
+    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