Class: Fastlane::Actions::IncrementVersionNumberInXcodeprojAction

Inherits:
Action
  • Object
show all
Defined in:
lib/fastlane/plugin/versioning/actions/increment_version_number_in_xcodeproj.rb

Documentation collapse

Class Method Summary collapse

Class Method Details

.authors ⇒ Object 



191
192
193
 
# File 'lib/fastlane/plugin/versioning/actions/increment_version_number_in_xcodeproj.rb', line 191

def self.authors
  ["jdouglas-nz", "neilb01"]
end

.available_options ⇒ Object 



121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/fastlane/plugin/versioning/actions/increment_version_number_in_xcodeproj.rb', line 121

def self.available_options
  [
    FastlaneCore::ConfigItem.new(key: :bump_type,
        env_name: "FL_VERSION_NUMBER_BUMP_TYPE",
        description: "The type of this version bump. Available: patch, minor, major",
        default_value: "patch",
        verify_block: proc do |value|
          UI.user_error!("Available values are 'patch', 'minor' and 'major'") unless ['patch', 'minor', 'major'].include? value
        end),
    FastlaneCore::ConfigItem.new(key: :version_number,
                  env_name: "FL_VERSION_NUMBER_VERSION_NUMBER",
                  description: "Change to a specific version. This will replace the bump type value",
                  optional: true),
    FastlaneCore::ConfigItem.new(key: :omit_zero_patch_version,
                  env_name: "FL_VERSION_NUMBER_OMIT_ZERO_PATCH_VERSION",
                  description: "If true omits zero in patch version(so 42.10.0 will become 42.10 and 42.10.1 will remain 42.10.1)",
                  default_value: false,
                  optional: true,
                  is_string: false),
    FastlaneCore::ConfigItem.new(key: :bundle_id,
                  env_name: "FL_APPSTORE_VERSION_NUMBER_BUNDLE_ID",
                  description: "Bundle ID of the application",
                  optional: true,
                  conflicting_options: %i[xcodeproj target build_configuration_name scheme],
                  is_string: true),
    FastlaneCore::ConfigItem.new(key: :xcodeproj,
                  env_name: "FL_VERSION_NUMBER_PROJECT",
                  description: "optional, you must specify the path to your main Xcode project if it is not in the project root directory",
                  optional: true,
                  conflicting_options: [:bundle_id],
                  verify_block: proc do |value|
                    UI.user_error!("Please pass the path to the project, not the workspace") if value.end_with? ".xcworkspace"
                    UI.user_error!("Could not find Xcode project at path '#{File.expand_path(value)}'") if !File.exist?(value) and !Helper.is_test?
                  end),
    FastlaneCore::ConfigItem.new(key: :target,
                  env_name: "FL_VERSION_NUMBER_TARGET",
                  optional: true,
                  conflicting_options: %i[bundle_id scheme],
                  description: "Specify a specific target if you have multiple per project, optional"),
    FastlaneCore::ConfigItem.new(key: :scheme,
                  env_name: "FL_VERSION_NUMBER_SCHEME",
                  optional: true,
                  conflicting_options: %i[bundle_id target],
                  description: "Specify a specific scheme if you have multiple per project, optional"),
    FastlaneCore::ConfigItem.new(key: :build_configuration_name,
                  optional: true,
                  conflicting_options: [:bundle_id],
                  description: "Specify a specific build configuration if you have different build settings for each configuration"),
    FastlaneCore::ConfigItem.new(key: :version_source,
                  optional: true,
                  default_value: 'xcodeproj',
                  verify_block: proc do |value|
                    UI.user_error!("Available values are 'xcodeproj' and 'appstore'") unless ['xcodeproj', 'appstore'].include? value
                  end,
                  description: "Source version to increment. Available options: xcodeproj, appstore"),
    FastlaneCore::ConfigItem.new(key: :country,
                  optional: true,
                  description: "Pass an optional country code, if your app's availability is limited to specific countries",
                  is_string: true),
    FastlaneCore::ConfigItem.new(key: :plist_build_setting_support,
                   description: "support automatic resolution of build setting from xcodeproj if not a literal value in the plist",
                   is_string: false,
                   default_value: false),
    FastlaneCore::ConfigItem.new(key: :skip_package_dependencies_resolution,
                   description: "Skips resolution of Swift Package Manager dependencies",
                   type: Boolean,
                   default_value: false)
  ]
end

.description ⇒ Object 



117
118
119
 
# File 'lib/fastlane/plugin/versioning/actions/increment_version_number_in_xcodeproj.rb', line 117

def self.description
  "Increment build number in xcodeproj"
end

.is_supported?(platform) ⇒ Boolean

Returns:

  • (Boolean) 


195
196
197
 
# File 'lib/fastlane/plugin/versioning/actions/increment_version_number_in_xcodeproj.rb', line 195

def self.is_supported?(platform)
  %i[ios mac android].include? platform
end

.run(params) ⇒ Object 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/fastlane/plugin/versioning/actions/increment_version_number_in_xcodeproj.rb', line 4

def self.run(params)
  if params[:version_number]
    next_version_number = params[:version_number]
  else
    case params[:version_source]
    when "xcodeproj"
      current_version = GetVersionNumberFromXcodeprojAction.run(params)
    when "appstore"
      current_version = GetAppStoreVersionNumberAction.run(params)
    end

    version_array = current_version.split(".").map(&:to_i)
    case params[:bump_type]
    when "patch"
      version_array[2] = (version_array[2] || 0) + 1
    when "minor"
      version_array[1] = (version_array[1] || 0) + 1
      version_array[2] = version_array[2] = 0
    when "major"
      version_array[0] = (version_array[0] || 0) + 1
      version_array[1] = version_array[1] = 0
      version_array[1] = version_array[2] = 0
    end

    if params[:omit_zero_patch_version] && version_array[2] == 0
      version_array.pop
    end

    next_version_number = version_array.join(".")
    end

  if Helper.test? && params[:xcodeproj].nil?
    params[:xcodeproj] = "/tmp/fastlane/tests/fastlane/xcodeproj/versioning_fixture_project.xcodeproj"
  else
    params[:xcodeproj] = Dir["*.xcodeproj"][0] unless params[:xcodeproj]
  end

  if params[:target]
    set_version_number_using_target(params, next_version_number)
  elsif params[:build_configuration_name] && params[:scheme]
    set_version_number_using_scheme(params, next_version_number)
  else
    set_all_xcodeproj_version_numbers(params, next_version_number)
  end

  Actions.lane_context[SharedValues::VERSION_NUMBER] = next_version_number
  next_version_number
end

.select_build_configuration_predicate(name, configuration) ⇒ Object 



70
71
72
73
74
 
# File 'lib/fastlane/plugin/versioning/actions/increment_version_number_in_xcodeproj.rb', line 70

def self.select_build_configuration_predicate(name, configuration)
  is_build_valid_configuration = configuration.isa == "XCBuildConfiguration" && !configuration.resolve_build_setting('PRODUCT_BUNDLE_IDENTIFIER').nil?
  is_build_valid_configuration &&= configuration.name == name unless name.nil?
  return is_build_valid_configuration
end

.set_all_xcodeproj_version_numbers(params, next_version_number) ⇒ Object 



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/fastlane/plugin/versioning/actions/increment_version_number_in_xcodeproj.rb', line 53

def self.set_all_xcodeproj_version_numbers(params, next_version_number)
  project = Xcodeproj::Project.open(params[:xcodeproj])

  if project.build_configurations.find { |config| !config.build_settings["MARKETING_VERSION"].nil? }
    project.build_configurations.each do |config|
      config.build_settings["MARKETING_VERSION"] = next_version_number
    end
  else
    configs = project.objects.select { |obj| select_build_configuration_predicate(nil, obj) }
    configs.each do |config|
      config.build_settings["MARKETING_VERSION"] = next_version_number
    end
  end
  project.save
end

.set_version_number_using_scheme(params, next_version_number) ⇒ Object 



104
105
106
107
108
109
110
111
 
# File 'lib/fastlane/plugin/versioning/actions/increment_version_number_in_xcodeproj.rb', line 104

def self.set_version_number_using_scheme(params, next_version_number)
    project = Xcodeproj::Project.open(params[:xcodeproj])
    configs = project.objects.select { |obj| select_build_configuration_predicate(params[:build_configuration_name], obj) }
    configs.each do |config|
      config.build_settings["MARKETING_VERSION"] = next_version_number
    end
    project.save
end

.set_version_number_using_target(params, next_version_number) ⇒ Object 



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/fastlane/plugin/versioning/actions/increment_version_number_in_xcodeproj.rb', line 76

def self.set_version_number_using_target(params, next_version_number)
  project = Xcodeproj::Project.open(params[:xcodeproj])
  if params[:target]
    target = project.targets.detect { |t| t.name == params[:target] }
  else
    # firstly we are trying to find modern application target
    target = project.targets.detect do |t|
      t.kind_of?(Xcodeproj::Project::Object::PBXNativeTarget) &&
        t.product_type == 'com.apple.product-type.application'
    end
    target = project.targets[0] if target.nil?
  end

  if params[:build_configuration_name]
    config = target.build_configurations.detect { |c| c.name == params[:build_configuration_name]}
    UI.message "updating #{config.name} to version #{next_version_number}"
    config.build_settings["MARKETING_VERSION"] = next_version_number
  else
    target.build_configurations.each do |config|
      UI.message "updating #{config.name} to version #{next_version_number}"
      config.build_settings["MARKETING_VERSION"] = next_version_number
    end unless target.nil?
  end


  project.save
end